home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / binutils.7 / binutils / binutils-2.7 / bfd / elf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-04  |  89.8 KB  |  3,433 lines
  1. /* ELF executable support for BFD.
  2.    Copyright 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
  3.  
  4. This file is part of BFD, the Binary File Descriptor library.
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19.  
  20. /*
  21.  
  22. SECTION
  23.     ELF backends
  24.  
  25.     BFD support for ELF formats is being worked on.
  26.     Currently, the best supported back ends are for sparc and i386
  27.     (running svr4 or Solaris 2).
  28.  
  29.     Documentation of the internals of the support code still needs
  30.     to be written.  The code is changing quickly enough that we
  31.     haven't bothered yet.
  32.  */
  33.  
  34. #include "bfd.h"
  35. #include "sysdep.h"
  36. #include "bfdlink.h"
  37. #include "libbfd.h"
  38. #define ARCH_SIZE 0
  39. #include "elf-bfd.h"
  40.  
  41. static INLINE struct elf_segment_map *make_mapping
  42.   PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
  43. static int elf_sort_sections PARAMS ((const PTR, const PTR));
  44. static boolean assign_file_positions_for_segments PARAMS ((bfd *));
  45. static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
  46. static boolean prep_headers PARAMS ((bfd *));
  47. static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **));
  48. static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *));
  49.  
  50. /* Standard ELF hash function.  Do not change this function; you will
  51.    cause invalid hash tables to be generated.  (Well, you would if this
  52.    were being used yet.)  */
  53. unsigned long
  54. bfd_elf_hash (name)
  55.      CONST unsigned char *name;
  56. {
  57.   unsigned long h = 0;
  58.   unsigned long g;
  59.   int ch;
  60.  
  61.   while ((ch = *name++) != '\0')
  62.     {
  63.       h = (h << 4) + ch;
  64.       if ((g = (h & 0xf0000000)) != 0)
  65.     {
  66.       h ^= g >> 24;
  67.       h &= ~g;
  68.     }
  69.     }
  70.   return h;
  71. }
  72.  
  73. /* Read a specified number of bytes at a specified offset in an ELF
  74.    file, into a newly allocated buffer, and return a pointer to the
  75.    buffer. */
  76.  
  77. static char *
  78. elf_read (abfd, offset, size)
  79.      bfd * abfd;
  80.      long offset;
  81.      unsigned int size;
  82. {
  83.   char *buf;
  84.  
  85.   if ((buf = bfd_alloc (abfd, size)) == NULL)
  86.     return NULL;
  87.   if (bfd_seek (abfd, offset, SEEK_SET) == -1)
  88.     return NULL;
  89.   if (bfd_read ((PTR) buf, size, 1, abfd) != size)
  90.     {
  91.       if (bfd_get_error () != bfd_error_system_call)
  92.     bfd_set_error (bfd_error_file_truncated);
  93.       return NULL;
  94.     }
  95.   return buf;
  96. }
  97.  
  98. boolean
  99. elf_mkobject (abfd)
  100.      bfd * abfd;
  101. {
  102.   /* this just does initialization */
  103.   /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
  104.   elf_tdata (abfd) = (struct elf_obj_tdata *)
  105.     bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
  106.   if (elf_tdata (abfd) == 0)
  107.     return false;
  108.   /* since everything is done at close time, do we need any
  109.      initialization? */
  110.  
  111.   return true;
  112. }
  113.  
  114. char *
  115. bfd_elf_get_str_section (abfd, shindex)
  116.      bfd * abfd;
  117.      unsigned int shindex;
  118. {
  119.   Elf_Internal_Shdr **i_shdrp;
  120.   char *shstrtab = NULL;
  121.   unsigned int offset;
  122.   unsigned int shstrtabsize;
  123.  
  124.   i_shdrp = elf_elfsections (abfd);
  125.   if (i_shdrp == 0 || i_shdrp[shindex] == 0)
  126.     return 0;
  127.  
  128.   shstrtab = (char *) i_shdrp[shindex]->contents;
  129.   if (shstrtab == NULL)
  130.     {
  131.       /* No cached one, attempt to read, and cache what we read. */
  132.       offset = i_shdrp[shindex]->sh_offset;
  133.       shstrtabsize = i_shdrp[shindex]->sh_size;
  134.       shstrtab = elf_read (abfd, offset, shstrtabsize);
  135.       i_shdrp[shindex]->contents = (PTR) shstrtab;
  136.     }
  137.   return shstrtab;
  138. }
  139.  
  140. char *
  141. bfd_elf_string_from_elf_section (abfd, shindex, strindex)
  142.      bfd * abfd;
  143.      unsigned int shindex;
  144.      unsigned int strindex;
  145. {
  146.   Elf_Internal_Shdr *hdr;
  147.  
  148.   if (strindex == 0)
  149.     return "";
  150.  
  151.   hdr = elf_elfsections (abfd)[shindex];
  152.  
  153.   if (hdr->contents == NULL
  154.       && bfd_elf_get_str_section (abfd, shindex) == NULL)
  155.     return NULL;
  156.  
  157.   return ((char *) hdr->contents) + strindex;
  158. }
  159.  
  160. /* Make a BFD section from an ELF section.  We store a pointer to the
  161.    BFD section in the bfd_section field of the header.  */
  162.  
  163. boolean
  164. _bfd_elf_make_section_from_shdr (abfd, hdr, name)
  165.      bfd *abfd;
  166.      Elf_Internal_Shdr *hdr;
  167.      const char *name;
  168. {
  169.   asection *newsect;
  170.   flagword flags;
  171.  
  172.   if (hdr->bfd_section != NULL)
  173.     {
  174.       BFD_ASSERT (strcmp (name,
  175.               bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
  176.       return true;
  177.     }
  178.  
  179.   newsect = bfd_make_section_anyway (abfd, name);
  180.   if (newsect == NULL)
  181.     return false;
  182.  
  183.   newsect->filepos = hdr->sh_offset;
  184.  
  185.   if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
  186.       || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
  187.       || ! bfd_set_section_alignment (abfd, newsect,
  188.                       bfd_log2 (hdr->sh_addralign)))
  189.     return false;
  190.  
  191.   flags = SEC_NO_FLAGS;
  192.   if (hdr->sh_type != SHT_NOBITS)
  193.     flags |= SEC_HAS_CONTENTS;
  194.   if ((hdr->sh_flags & SHF_ALLOC) != 0)
  195.     {
  196.       flags |= SEC_ALLOC;
  197.       if (hdr->sh_type != SHT_NOBITS)
  198.     flags |= SEC_LOAD;
  199.     }
  200.   if ((hdr->sh_flags & SHF_WRITE) == 0)
  201.     flags |= SEC_READONLY;
  202.   if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
  203.     flags |= SEC_CODE;
  204.   else if ((flags & SEC_LOAD) != 0)
  205.     flags |= SEC_DATA;
  206.  
  207.   /* The debugging sections appear to be recognized only by name, not
  208.      any sort of flag.  */
  209.   if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0
  210.       || strncmp (name, ".line", sizeof ".line" - 1) == 0
  211.       || strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
  212.     flags |= SEC_DEBUGGING;
  213.  
  214.   if (! bfd_set_section_flags (abfd, newsect, flags))
  215.     return false;
  216.  
  217.   if ((flags & SEC_ALLOC) != 0)
  218.     {
  219.       Elf_Internal_Phdr *phdr;
  220.       unsigned int i;
  221.  
  222.       /* Look through the phdrs to see if we need to adjust the lma.  */
  223.       phdr = elf_tdata (abfd)->phdr;
  224.       for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
  225.     {
  226.       if (phdr->p_type == PT_LOAD
  227.           && phdr->p_paddr != 0
  228.           && phdr->p_vaddr != phdr->p_paddr
  229.           && phdr->p_vaddr <= hdr->sh_addr
  230.           && phdr->p_vaddr + phdr->p_memsz >= hdr->sh_addr + hdr->sh_size)
  231.         {
  232.           newsect->lma += phdr->p_paddr - phdr->p_vaddr;
  233.           break;
  234.         }
  235.     }
  236.     }
  237.  
  238.   hdr->bfd_section = newsect;
  239.   elf_section_data (newsect)->this_hdr = *hdr;
  240.  
  241.   return true;
  242. }
  243.  
  244. /*
  245. INTERNAL_FUNCTION
  246.     bfd_elf_find_section
  247.  
  248. SYNOPSIS
  249.     struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
  250.  
  251. DESCRIPTION
  252.     Helper functions for GDB to locate the string tables.
  253.     Since BFD hides string tables from callers, GDB needs to use an
  254.     internal hook to find them.  Sun's .stabstr, in particular,
  255.     isn't even pointed to by the .stab section, so ordinary
  256.     mechanisms wouldn't work to find it, even if we had some.
  257. */
  258.  
  259. struct elf_internal_shdr *
  260. bfd_elf_find_section (abfd, name)
  261.      bfd * abfd;
  262.      char *name;
  263. {
  264.   Elf_Internal_Shdr **i_shdrp;
  265.   char *shstrtab;
  266.   unsigned int max;
  267.   unsigned int i;
  268.  
  269.   i_shdrp = elf_elfsections (abfd);
  270.   if (i_shdrp != NULL)
  271.     {
  272.       shstrtab = bfd_elf_get_str_section (abfd, elf_elfheader (abfd)->e_shstrndx);
  273.       if (shstrtab != NULL)
  274.     {
  275.       max = elf_elfheader (abfd)->e_shnum;
  276.       for (i = 1; i < max; i++)
  277.         if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
  278.           return i_shdrp[i];
  279.     }
  280.     }
  281.   return 0;
  282. }
  283.  
  284. const char *const bfd_elf_section_type_names[] = {
  285.   "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
  286.   "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
  287.   "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
  288. };
  289.  
  290. /* ELF relocs are against symbols.  If we are producing relocateable
  291.    output, and the reloc is against an external symbol, and nothing
  292.    has given us any additional addend, the resulting reloc will also
  293.    be against the same symbol.  In such a case, we don't want to
  294.    change anything about the way the reloc is handled, since it will
  295.    all be done at final link time.  Rather than put special case code
  296.    into bfd_perform_relocation, all the reloc types use this howto
  297.    function.  It just short circuits the reloc if producing
  298.    relocateable output against an external symbol.  */
  299.  
  300. /*ARGSUSED*/
  301. bfd_reloc_status_type
  302. bfd_elf_generic_reloc (abfd,
  303.                reloc_entry,
  304.                symbol,
  305.                data,
  306.                input_section,
  307.                output_bfd,
  308.                error_message)
  309.      bfd *abfd;
  310.      arelent *reloc_entry;
  311.      asymbol *symbol;
  312.      PTR data;
  313.      asection *input_section;
  314.      bfd *output_bfd;
  315.      char **error_message;
  316. {
  317.   if (output_bfd != (bfd *) NULL
  318.       && (symbol->flags & BSF_SECTION_SYM) == 0
  319.       && (! reloc_entry->howto->partial_inplace
  320.       || reloc_entry->addend == 0))
  321.     {
  322.       reloc_entry->address += input_section->output_offset;
  323.       return bfd_reloc_ok;
  324.     }
  325.  
  326.   return bfd_reloc_continue;
  327. }
  328.  
  329. /* Print out the program headers.  */
  330.  
  331. boolean
  332. _bfd_elf_print_private_bfd_data (abfd, farg)
  333.      bfd *abfd;
  334.      PTR farg;
  335. {
  336.   FILE *f = (FILE *) farg;
  337.   Elf_Internal_Phdr *p;
  338.   asection *s;
  339.   bfd_byte *dynbuf = NULL;
  340.  
  341.   p = elf_tdata (abfd)->phdr;
  342.   if (p != NULL)
  343.     {
  344.       unsigned int i, c;
  345.  
  346.       fprintf (f, "\nProgram Header:\n");
  347.       c = elf_elfheader (abfd)->e_phnum;
  348.       for (i = 0; i < c; i++, p++)
  349.     {
  350.       const char *s;
  351.       char buf[20];
  352.  
  353.       switch (p->p_type)
  354.         {
  355.         case PT_NULL: s = "NULL"; break;
  356.         case PT_LOAD: s = "LOAD"; break;
  357.         case PT_DYNAMIC: s = "DYNAMIC"; break;
  358.         case PT_INTERP: s = "INTERP"; break;
  359.         case PT_NOTE: s = "NOTE"; break;
  360.         case PT_SHLIB: s = "SHLIB"; break;
  361.         case PT_PHDR: s = "PHDR"; break;
  362.         default: sprintf (buf, "0x%lx", p->p_type); s = buf; break;
  363.         }
  364.       fprintf (f, "%8s off    0x", s);
  365.       fprintf_vma (f, p->p_offset);
  366.       fprintf (f, " vaddr 0x");
  367.       fprintf_vma (f, p->p_vaddr);
  368.       fprintf (f, " paddr 0x");
  369.       fprintf_vma (f, p->p_paddr);
  370.       fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
  371.       fprintf (f, "         filesz 0x");
  372.       fprintf_vma (f, p->p_filesz);
  373.       fprintf (f, " memsz 0x");
  374.       fprintf_vma (f, p->p_memsz);
  375.       fprintf (f, " flags %c%c%c",
  376.            (p->p_flags & PF_R) != 0 ? 'r' : '-',
  377.            (p->p_flags & PF_W) != 0 ? 'w' : '-',
  378.            (p->p_flags & PF_X) != 0 ? 'x' : '-');
  379.       if ((p->p_flags &~ (PF_R | PF_W | PF_X)) != 0)
  380.         fprintf (f, " %lx", p->p_flags &~ (PF_R | PF_W | PF_X));
  381.       fprintf (f, "\n");
  382.     }
  383.     }
  384.  
  385.   s = bfd_get_section_by_name (abfd, ".dynamic");
  386.   if (s != NULL)
  387.     {
  388.       int elfsec;
  389.       unsigned long link;
  390.       bfd_byte *extdyn, *extdynend;
  391.       size_t extdynsize;
  392.       void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
  393.  
  394.       fprintf (f, "\nDynamic Section:\n");
  395.  
  396.       dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
  397.       if (dynbuf == NULL)
  398.     goto error_return;
  399.       if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
  400.                       s->_raw_size))
  401.     goto error_return;
  402.  
  403.       elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
  404.       if (elfsec == -1)
  405.     goto error_return;
  406.       link = elf_elfsections (abfd)[elfsec]->sh_link;
  407.  
  408.       extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
  409.       swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
  410.  
  411.       extdyn = dynbuf;
  412.       extdynend = extdyn + s->_raw_size;
  413.       for (; extdyn < extdynend; extdyn += extdynsize)
  414.     {
  415.       Elf_Internal_Dyn dyn;
  416.       const char *name;
  417.       char ab[20];
  418.       boolean stringp;
  419.  
  420.       (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
  421.  
  422.       if (dyn.d_tag == DT_NULL)
  423.         break;
  424.  
  425.       stringp = false;
  426.       switch (dyn.d_tag)
  427.         {
  428.         default:
  429.           sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
  430.           name = ab;
  431.           break;
  432.  
  433.         case DT_NEEDED: name = "NEEDED"; stringp = true; break;
  434.         case DT_PLTRELSZ: name = "PLTRELSZ"; break;
  435.         case DT_PLTGOT: name = "PLTGOT"; break;
  436.         case DT_HASH: name = "HASH"; break;
  437.         case DT_STRTAB: name = "STRTAB"; break;
  438.         case DT_SYMTAB: name = "SYMTAB"; break;
  439.         case DT_RELA: name = "RELA"; break;
  440.         case DT_RELASZ: name = "RELASZ"; break;
  441.         case DT_RELAENT: name = "RELAENT"; break;
  442.         case DT_STRSZ: name = "STRSZ"; break;
  443.         case DT_SYMENT: name = "SYMENT"; break;
  444.         case DT_INIT: name = "INIT"; break;
  445.         case DT_FINI: name = "FINI"; break;
  446.         case DT_SONAME: name = "SONAME"; stringp = true; break;
  447.         case DT_RPATH: name = "RPATH"; stringp = true; break;
  448.         case DT_SYMBOLIC: name = "SYMBOLIC"; break;
  449.         case DT_REL: name = "REL"; break;
  450.         case DT_RELSZ: name = "RELSZ"; break;
  451.         case DT_RELENT: name = "RELENT"; break;
  452.         case DT_PLTREL: name = "PLTREL"; break;
  453.         case DT_DEBUG: name = "DEBUG"; break;
  454.         case DT_TEXTREL: name = "TEXTREL"; break;
  455.         case DT_JMPREL: name = "JMPREL"; break;
  456.         }
  457.  
  458.       fprintf (f, "  %-11s ", name);
  459.       if (! stringp)
  460.         fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
  461.       else
  462.         {
  463.           const char *string;
  464.  
  465.           string = bfd_elf_string_from_elf_section (abfd, link,
  466.                             dyn.d_un.d_val);
  467.           if (string == NULL)
  468.         goto error_return;
  469.           fprintf (f, "%s", string);
  470.         }
  471.       fprintf (f, "\n");
  472.     }
  473.  
  474.       free (dynbuf);
  475.       dynbuf = NULL;
  476.     }
  477.  
  478.   return true;
  479.  
  480.  error_return:
  481.   if (dynbuf != NULL)
  482.     free (dynbuf);
  483.   return false;
  484. }
  485.  
  486. /* Display ELF-specific fields of a symbol.  */
  487. void
  488. bfd_elf_print_symbol (ignore_abfd, filep, symbol, how)
  489.      bfd *ignore_abfd;
  490.      PTR filep;
  491.      asymbol *symbol;
  492.      bfd_print_symbol_type how;
  493. {
  494.   FILE *file = (FILE *) filep;
  495.   switch (how)
  496.     {
  497.     case bfd_print_symbol_name:
  498.       fprintf (file, "%s", symbol->name);
  499.       break;
  500.     case bfd_print_symbol_more:
  501.       fprintf (file, "elf ");
  502.       fprintf_vma (file, symbol->value);
  503.       fprintf (file, " %lx", (long) symbol->flags);
  504.       break;
  505.     case bfd_print_symbol_all:
  506.       {
  507.     CONST char *section_name;
  508.     section_name = symbol->section ? symbol->section->name : "(*none*)";
  509.     bfd_print_symbol_vandf ((PTR) file, symbol);
  510.     fprintf (file, " %s\t", section_name);
  511.     /* Print the "other" value for a symbol.  For common symbols,
  512.        we've already printed the size; now print the alignment.
  513.        For other symbols, we have no specified alignment, and
  514.        we've printed the address; now print the size.  */
  515.     fprintf_vma (file,
  516.              (bfd_is_com_section (symbol->section)
  517.               ? ((elf_symbol_type *) symbol)->internal_elf_sym.st_value
  518.               : ((elf_symbol_type *) symbol)->internal_elf_sym.st_size));
  519.     fprintf (file, " %s", symbol->name);
  520.       }
  521.       break;
  522.     }
  523. }
  524.  
  525. /* Create an entry in an ELF linker hash table.  */
  526.  
  527. struct bfd_hash_entry *
  528. _bfd_elf_link_hash_newfunc (entry, table, string)
  529.      struct bfd_hash_entry *entry;
  530.      struct bfd_hash_table *table;
  531.      const char *string;
  532. {
  533.   struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
  534.  
  535.   /* Allocate the structure if it has not already been allocated by a
  536.      subclass.  */
  537.   if (ret == (struct elf_link_hash_entry *) NULL)
  538.     ret = ((struct elf_link_hash_entry *)
  539.        bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry)));
  540.   if (ret == (struct elf_link_hash_entry *) NULL)
  541.     return (struct bfd_hash_entry *) ret;
  542.  
  543.   /* Call the allocation method of the superclass.  */
  544.   ret = ((struct elf_link_hash_entry *)
  545.      _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
  546.                  table, string));
  547.   if (ret != (struct elf_link_hash_entry *) NULL)
  548.     {
  549.       /* Set local fields.  */
  550.       ret->indx = -1;
  551.       ret->size = 0;
  552.       ret->dynindx = -1;
  553.       ret->dynstr_index = 0;
  554.       ret->weakdef = NULL;
  555.       ret->got_offset = (bfd_vma) -1;
  556.       ret->plt_offset = (bfd_vma) -1;
  557.       ret->linker_section_pointer = (elf_linker_section_pointers_t *)0;
  558.       ret->type = STT_NOTYPE;
  559.       /* Assume that we have been called by a non-ELF symbol reader.
  560.          This flag is then reset by the code which reads an ELF input
  561.          file.  This ensures that a symbol created by a non-ELF symbol
  562.          reader will have the flag set correctly.  */
  563.       ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
  564.     }
  565.  
  566.   return (struct bfd_hash_entry *) ret;
  567. }
  568.  
  569. /* Initialize an ELF linker hash table.  */
  570.  
  571. boolean
  572. _bfd_elf_link_hash_table_init (table, abfd, newfunc)
  573.      struct elf_link_hash_table *table;
  574.      bfd *abfd;
  575.      struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
  576.                         struct bfd_hash_table *,
  577.                         const char *));
  578. {
  579.   table->dynamic_sections_created = false;
  580.   table->dynobj = NULL;
  581.   /* The first dynamic symbol is a dummy.  */
  582.   table->dynsymcount = 1;
  583.   table->dynstr = NULL;
  584.   table->bucketcount = 0;
  585.   table->needed = NULL;
  586.   table->hgot = NULL;
  587.   table->stab_info = NULL;
  588.   return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
  589. }
  590.  
  591. /* Create an ELF linker hash table.  */
  592.  
  593. struct bfd_link_hash_table *
  594. _bfd_elf_link_hash_table_create (abfd)
  595.      bfd *abfd;
  596. {
  597.   struct elf_link_hash_table *ret;
  598.  
  599.   ret = ((struct elf_link_hash_table *)
  600.      bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
  601.   if (ret == (struct elf_link_hash_table *) NULL)
  602.     return NULL;
  603.  
  604.   if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
  605.     {
  606.       bfd_release (abfd, ret);
  607.       return NULL;
  608.     }
  609.  
  610.   return &ret->root;
  611. }
  612.  
  613. /* This is a hook for the ELF emulation code in the generic linker to
  614.    tell the backend linker what file name to use for the DT_NEEDED
  615.    entry for a dynamic object.  The generic linker passes name as an
  616.    empty string to indicate that no DT_NEEDED entry should be made.  */
  617.  
  618. void
  619. bfd_elf_set_dt_needed_name (abfd, name)
  620.      bfd *abfd;
  621.      const char *name;
  622. {
  623.   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
  624.       && bfd_get_format (abfd) == bfd_object)
  625.     elf_dt_name (abfd) = name;
  626. }
  627.  
  628. /* Get the list of DT_NEEDED entries for a link.  This is a hook for
  629.    the ELF emulation code.  */
  630.  
  631. struct bfd_link_needed_list *
  632. bfd_elf_get_needed_list (abfd, info)
  633.      bfd *abfd;
  634.      struct bfd_link_info *info;
  635. {
  636.   if (info->hash->creator->flavour != bfd_target_elf_flavour)
  637.     return NULL;
  638.   return elf_hash_table (info)->needed;
  639. }
  640.  
  641. /* Get the name actually used for a dynamic object for a link.  This
  642.    is the SONAME entry if there is one.  Otherwise, it is the string
  643.    passed to bfd_elf_set_dt_needed_name, or it is the filename.  */
  644.  
  645. const char *
  646. bfd_elf_get_dt_soname (abfd)
  647.      bfd *abfd;
  648. {
  649.   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
  650.       && bfd_get_format (abfd) == bfd_object)
  651.     return elf_dt_name (abfd);
  652.   return NULL;
  653. }
  654.  
  655. /* Allocate an ELF string table--force the first byte to be zero.  */
  656.  
  657. struct bfd_strtab_hash *
  658. _bfd_elf_stringtab_init ()
  659. {
  660.   struct bfd_strtab_hash *ret;
  661.  
  662.   ret = _bfd_stringtab_init ();
  663.   if (ret != NULL)
  664.     {
  665.       bfd_size_type loc;
  666.  
  667.       loc = _bfd_stringtab_add (ret, "", true, false);
  668.       BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
  669.       if (loc == (bfd_size_type) -1)
  670.     {
  671.       _bfd_stringtab_free (ret);
  672.       ret = NULL;
  673.     }
  674.     }
  675.   return ret;
  676. }
  677.  
  678. /* ELF .o/exec file reading */
  679.  
  680. /* Create a new bfd section from an ELF section header. */
  681.  
  682. boolean
  683. bfd_section_from_shdr (abfd, shindex)
  684.      bfd *abfd;
  685.      unsigned int shindex;
  686. {
  687.   Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
  688.   Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
  689.   struct elf_backend_data *bed = get_elf_backend_data (abfd);
  690.   char *name;
  691.  
  692.   name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
  693.  
  694.   switch (hdr->sh_type)
  695.     {
  696.     case SHT_NULL:
  697.       /* Inactive section. Throw it away.  */
  698.       return true;
  699.  
  700.     case SHT_PROGBITS:    /* Normal section with contents.  */
  701.     case SHT_DYNAMIC:    /* Dynamic linking information.  */
  702.     case SHT_NOBITS:    /* .bss section.  */
  703.     case SHT_HASH:    /* .hash section.  */
  704.     case SHT_NOTE:    /* .note section.  */
  705.       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
  706.  
  707.     case SHT_SYMTAB:        /* A symbol table */
  708.       if (elf_onesymtab (abfd) == shindex)
  709.     return true;
  710.  
  711.       BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
  712.       BFD_ASSERT (elf_onesymtab (abfd) == 0);
  713.       elf_onesymtab (abfd) = shindex;
  714.       elf_tdata (abfd)->symtab_hdr = *hdr;
  715.       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
  716.       abfd->flags |= HAS_SYMS;
  717.  
  718.       /* Sometimes a shared object will map in the symbol table.  If
  719.          SHF_ALLOC is set, and this is a shared object, then we also
  720.          treat this section as a BFD section.  We can not base the
  721.          decision purely on SHF_ALLOC, because that flag is sometimes
  722.          set in a relocateable object file, which would confuse the
  723.          linker.  */
  724.       if ((hdr->sh_flags & SHF_ALLOC) != 0
  725.       && (abfd->flags & DYNAMIC) != 0
  726.       && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
  727.     return false;
  728.  
  729.       return true;
  730.  
  731.     case SHT_DYNSYM:        /* A dynamic symbol table */
  732.       if (elf_dynsymtab (abfd) == shindex)
  733.     return true;
  734.  
  735.       BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
  736.       BFD_ASSERT (elf_dynsymtab (abfd) == 0);
  737.       elf_dynsymtab (abfd) = shindex;
  738.       elf_tdata (abfd)->dynsymtab_hdr = *hdr;
  739.       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
  740.       abfd->flags |= HAS_SYMS;
  741.  
  742.       /* Besides being a symbol table, we also treat this as a regular
  743.      section, so that objcopy can handle it.  */
  744.       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
  745.  
  746.     case SHT_STRTAB:        /* A string table */
  747.       if (hdr->bfd_section != NULL)
  748.     return true;
  749.       if (ehdr->e_shstrndx == shindex)
  750.     {
  751.       elf_tdata (abfd)->shstrtab_hdr = *hdr;
  752.       elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
  753.       return true;
  754.     }
  755.       {
  756.     unsigned int i;
  757.  
  758.     for (i = 1; i < ehdr->e_shnum; i++)
  759.       {
  760.         Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
  761.         if (hdr2->sh_link == shindex)
  762.           {
  763.         if (! bfd_section_from_shdr (abfd, i))
  764.           return false;
  765.         if (elf_onesymtab (abfd) == i)
  766.           {
  767.             elf_tdata (abfd)->strtab_hdr = *hdr;
  768.             elf_elfsections (abfd)[shindex] =
  769.               &elf_tdata (abfd)->strtab_hdr;
  770.             return true;
  771.           }
  772.         if (elf_dynsymtab (abfd) == i)
  773.           {
  774.             elf_tdata (abfd)->dynstrtab_hdr = *hdr;
  775.             elf_elfsections (abfd)[shindex] = hdr =
  776.               &elf_tdata (abfd)->dynstrtab_hdr;
  777.             /* We also treat this as a regular section, so
  778.                that objcopy can handle it.  */
  779.             break;
  780.           }
  781. #if 0 /* Not handling other string tables specially right now.  */
  782.         hdr2 = elf_elfsections (abfd)[i];    /* in case it moved */
  783.         /* We have a strtab for some random other section.  */
  784.         newsect = (asection *) hdr2->bfd_section;
  785.         if (!newsect)
  786.           break;
  787.         hdr->bfd_section = newsect;
  788.         hdr2 = &elf_section_data (newsect)->str_hdr;
  789.         *hdr2 = *hdr;
  790.         elf_elfsections (abfd)[shindex] = hdr2;
  791. #endif
  792.           }
  793.       }
  794.       }
  795.  
  796.       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
  797.  
  798.     case SHT_REL:
  799.     case SHT_RELA:
  800.       /* *These* do a lot of work -- but build no sections!  */
  801.       {
  802.     asection *target_sect;
  803.     Elf_Internal_Shdr *hdr2;
  804.  
  805.     /* For some incomprehensible reason Oracle distributes
  806.        libraries for Solaris in which some of the objects have
  807.        bogus sh_link fields.  It would be nice if we could just
  808.        reject them, but, unfortunately, some people need to use
  809.        them.  We scan through the section headers; if we find only
  810.        one suitable symbol table, we clobber the sh_link to point
  811.        to it.  I hope this doesn't break anything.  */
  812.     if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
  813.         && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
  814.       {
  815.         int scan;
  816.         int found;
  817.  
  818.         found = 0;
  819.         for (scan = 1; scan < ehdr->e_shnum; scan++)
  820.           {
  821.         if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
  822.             || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
  823.           {
  824.             if (found != 0)
  825.               {
  826.             found = 0;
  827.             break;
  828.               }
  829.             found = scan;
  830.           }
  831.           }
  832.         if (found != 0)
  833.           hdr->sh_link = found;
  834.       }
  835.  
  836.     /* Get the symbol table.  */
  837.     if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
  838.         && ! bfd_section_from_shdr (abfd, hdr->sh_link))
  839.       return false;
  840.  
  841.     /* If this reloc section does not use the main symbol table we
  842.        don't treat it as a reloc section.  BFD can't adequately
  843.        represent such a section, so at least for now, we don't
  844.        try.  We just present it as a normal section.  */
  845.     if (hdr->sh_link != elf_onesymtab (abfd))
  846.       return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
  847.  
  848.     if (! bfd_section_from_shdr (abfd, hdr->sh_info))
  849.       return false;
  850.     target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
  851.     if (target_sect == NULL)
  852.       return false;
  853.  
  854.     if ((target_sect->flags & SEC_RELOC) == 0
  855.         || target_sect->reloc_count == 0)
  856.       hdr2 = &elf_section_data (target_sect)->rel_hdr;
  857.     else
  858.       {
  859.         BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
  860.         hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
  861.         elf_section_data (target_sect)->rel_hdr2 = hdr2;
  862.       }
  863.     *hdr2 = *hdr;
  864.     elf_elfsections (abfd)[shindex] = hdr2;
  865.     target_sect->reloc_count += hdr->sh_size / hdr->sh_entsize;
  866.     target_sect->flags |= SEC_RELOC;
  867.     target_sect->relocation = NULL;
  868.     target_sect->rel_filepos = hdr->sh_offset;
  869.     abfd->flags |= HAS_RELOC;
  870.     return true;
  871.       }
  872.       break;
  873.  
  874.     case SHT_SHLIB:
  875.       return true;
  876.  
  877.     default:
  878.       /* Check for any processor-specific section types.  */
  879.       {
  880.     if (bed->elf_backend_section_from_shdr)
  881.       (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
  882.       }
  883.       break;
  884.     }
  885.  
  886.   return true;
  887. }
  888.  
  889. /* Given an ELF section number, retrieve the corresponding BFD
  890.    section.  */
  891.  
  892. asection *
  893. bfd_section_from_elf_index (abfd, index)
  894.      bfd *abfd;
  895.      unsigned int index;
  896. {
  897.   BFD_ASSERT (index > 0 && index < SHN_LORESERVE);
  898.   if (index >= elf_elfheader (abfd)->e_shnum)
  899.     return NULL;
  900.   return elf_elfsections (abfd)[index]->bfd_section;
  901. }
  902.  
  903. boolean
  904. _bfd_elf_new_section_hook (abfd, sec)
  905.      bfd *abfd;
  906.      asection *sec;
  907. {
  908.   struct bfd_elf_section_data *sdata;
  909.  
  910.   sdata = (struct bfd_elf_section_data *) bfd_alloc (abfd, sizeof (*sdata));
  911.   if (!sdata)
  912.     return false;
  913.   sec->used_by_bfd = (PTR) sdata;
  914.   memset (sdata, 0, sizeof (*sdata));
  915.   return true;
  916. }
  917.  
  918. /* Create a new bfd section from an ELF program header.
  919.  
  920.    Since program segments have no names, we generate a synthetic name
  921.    of the form segment<NUM>, where NUM is generally the index in the
  922.    program header table.  For segments that are split (see below) we
  923.    generate the names segment<NUM>a and segment<NUM>b.
  924.  
  925.    Note that some program segments may have a file size that is different than
  926.    (less than) the memory size.  All this means is that at execution the
  927.    system must allocate the amount of memory specified by the memory size,
  928.    but only initialize it with the first "file size" bytes read from the
  929.    file.  This would occur for example, with program segments consisting
  930.    of combined data+bss.
  931.  
  932.    To handle the above situation, this routine generates TWO bfd sections
  933.    for the single program segment.  The first has the length specified by
  934.    the file size of the segment, and the second has the length specified
  935.    by the difference between the two sizes.  In effect, the segment is split
  936.    into it's initialized and uninitialized parts.
  937.  
  938.  */
  939.  
  940. boolean
  941. bfd_section_from_phdr (abfd, hdr, index)
  942.      bfd *abfd;
  943.      Elf_Internal_Phdr *hdr;
  944.      int index;
  945. {
  946.   asection *newsect;
  947.   char *name;
  948.   char namebuf[64];
  949.   int split;
  950.  
  951.   split = ((hdr->p_memsz > 0) &&
  952.        (hdr->p_filesz > 0) &&
  953.        (hdr->p_memsz > hdr->p_filesz));
  954.   sprintf (namebuf, split ? "segment%da" : "segment%d", index);
  955.   name = bfd_alloc (abfd, strlen (namebuf) + 1);
  956.   if (!name)
  957.     return false;
  958.   strcpy (name, namebuf);
  959.   newsect = bfd_make_section (abfd, name);
  960.   if (newsect == NULL)
  961.     return false;
  962.   newsect->vma = hdr->p_vaddr;
  963.   newsect->lma = hdr->p_paddr;
  964.   newsect->_raw_size = hdr->p_filesz;
  965.   newsect->filepos = hdr->p_offset;
  966.   newsect->flags |= SEC_HAS_CONTENTS;
  967.   if (hdr->p_type == PT_LOAD)
  968.     {
  969.       newsect->flags |= SEC_ALLOC;
  970.       newsect->flags |= SEC_LOAD;
  971.       if (hdr->p_flags & PF_X)
  972.     {
  973.       /* FIXME: all we known is that it has execute PERMISSION,
  974.          may be data. */
  975.       newsect->flags |= SEC_CODE;
  976.     }
  977.     }
  978.   if (!(hdr->p_flags & PF_W))
  979.     {
  980.       newsect->flags |= SEC_READONLY;
  981.     }
  982.  
  983.   if (split)
  984.     {
  985.       sprintf (namebuf, "segment%db", index);
  986.       name = bfd_alloc (abfd, strlen (namebuf) + 1);
  987.       if (!name)
  988.     return false;
  989.       strcpy (name, namebuf);
  990.       newsect = bfd_make_section (abfd, name);
  991.       if (newsect == NULL)
  992.     return false;
  993.       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
  994.       newsect->lma = hdr->p_paddr + hdr->p_filesz;
  995.       newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
  996.       if (hdr->p_type == PT_LOAD)
  997.     {
  998.       newsect->flags |= SEC_ALLOC;
  999.       if (hdr->p_flags & PF_X)
  1000.         newsect->flags |= SEC_CODE;
  1001.     }
  1002.       if (!(hdr->p_flags & PF_W))
  1003.     newsect->flags |= SEC_READONLY;
  1004.     }
  1005.  
  1006.   return true;
  1007. }
  1008.  
  1009. /* Set up an ELF internal section header for a section.  */
  1010.  
  1011. /*ARGSUSED*/
  1012. static void
  1013. elf_fake_sections (abfd, asect, failedptrarg)
  1014.      bfd *abfd;
  1015.      asection *asect;
  1016.      PTR failedptrarg;
  1017. {
  1018.   struct elf_backend_data *bed = get_elf_backend_data (abfd);
  1019.   boolean *failedptr = (boolean *) failedptrarg;
  1020.   Elf_Internal_Shdr *this_hdr;
  1021.  
  1022.   if (*failedptr)
  1023.     {
  1024.       /* We already failed; just get out of the bfd_map_over_sections
  1025.          loop.  */
  1026.       return;
  1027.     }
  1028.  
  1029.   this_hdr = &elf_section_data (asect)->this_hdr;
  1030.  
  1031.   this_hdr->sh_name = (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd),
  1032.                               asect->name,
  1033.                               true, false);
  1034.   if (this_hdr->sh_name == (unsigned long) -1)
  1035.     {
  1036.       *failedptr = true;
  1037.       return;
  1038.     }
  1039.  
  1040.   this_hdr->sh_flags = 0;
  1041.  
  1042.   if ((asect->flags & SEC_ALLOC) != 0
  1043.       || asect->user_set_vma)
  1044.     this_hdr->sh_addr = asect->vma;
  1045.   else
  1046.     this_hdr->sh_addr = 0;
  1047.  
  1048.   this_hdr->sh_offset = 0;
  1049.   this_hdr->sh_size = asect->_raw_size;
  1050.   this_hdr->sh_link = 0;
  1051.   this_hdr->sh_addralign = 1 << asect->alignment_power;
  1052.   /* The sh_entsize and sh_info fields may have been set already by
  1053.      copy_private_section_data.  */
  1054.  
  1055.   this_hdr->bfd_section = asect;
  1056.   this_hdr->contents = NULL;
  1057.  
  1058.   /* FIXME: This should not be based on section names.  */
  1059.   if (strcmp (asect->name, ".dynstr") == 0)
  1060.     this_hdr->sh_type = SHT_STRTAB;
  1061.   else if (strcmp (asect->name, ".hash") == 0)
  1062.     {
  1063.       this_hdr->sh_type = SHT_HASH;
  1064.       this_hdr->sh_entsize = bed->s->arch_size / 8;
  1065.     }
  1066.   else if (strcmp (asect->name, ".dynsym") == 0)
  1067.     {
  1068.       this_hdr->sh_type = SHT_DYNSYM;
  1069.       this_hdr->sh_entsize = bed->s->sizeof_sym;
  1070.     }
  1071.   else if (strcmp (asect->name, ".dynamic") == 0)
  1072.     {
  1073.       this_hdr->sh_type = SHT_DYNAMIC;
  1074.       this_hdr->sh_entsize = bed->s->sizeof_dyn;
  1075.     }
  1076.   else if (strncmp (asect->name, ".rela", 5) == 0
  1077.        && get_elf_backend_data (abfd)->use_rela_p)
  1078.     {
  1079.       this_hdr->sh_type = SHT_RELA;
  1080.       this_hdr->sh_entsize = bed->s->sizeof_rela;
  1081.     }
  1082.   else if (strncmp (asect->name, ".rel", 4) == 0
  1083.        && ! get_elf_backend_data (abfd)->use_rela_p)
  1084.     {
  1085.       this_hdr->sh_type = SHT_REL;
  1086.       this_hdr->sh_entsize = bed->s->sizeof_rel;
  1087.     }
  1088.   else if (strcmp (asect->name, ".note") == 0)
  1089.     this_hdr->sh_type = SHT_NOTE;
  1090.   else if (strncmp (asect->name, ".stab", 5) == 0
  1091.        && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
  1092.     this_hdr->sh_type = SHT_STRTAB;
  1093.   else if ((asect->flags & SEC_ALLOC) != 0
  1094.        && (asect->flags & SEC_LOAD) != 0)
  1095.     this_hdr->sh_type = SHT_PROGBITS;
  1096.   else if ((asect->flags & SEC_ALLOC) != 0
  1097.        && ((asect->flags & SEC_LOAD) == 0))
  1098.     this_hdr->sh_type = SHT_NOBITS;
  1099.   else
  1100.     {
  1101.       /* Who knows?  */
  1102.       this_hdr->sh_type = SHT_PROGBITS;
  1103.     }
  1104.  
  1105.   if ((asect->flags & SEC_ALLOC) != 0)
  1106.     this_hdr->sh_flags |= SHF_ALLOC;
  1107.   if ((asect->flags & SEC_READONLY) == 0)
  1108.     this_hdr->sh_flags |= SHF_WRITE;
  1109.   if ((asect->flags & SEC_CODE) != 0)
  1110.     this_hdr->sh_flags |= SHF_EXECINSTR;
  1111.  
  1112.   /* Check for processor-specific section types.  */
  1113.   {
  1114.     struct elf_backend_data *bed = get_elf_backend_data (abfd);
  1115.  
  1116.     if (bed->elf_backend_fake_sections)
  1117.       (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
  1118.   }
  1119.  
  1120.   /* If the section has relocs, set up a section header for the
  1121.      SHT_REL[A] section.  */
  1122.   if ((asect->flags & SEC_RELOC) != 0)
  1123.     {
  1124.       Elf_Internal_Shdr *rela_hdr;
  1125.       int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
  1126.       char *name;
  1127.  
  1128.       rela_hdr = &elf_section_data (asect)->rel_hdr;
  1129.       name = bfd_alloc (abfd, sizeof ".rela" + strlen (asect->name));
  1130.       if (name == NULL)
  1131.     {
  1132.       *failedptr = true;
  1133.       return;
  1134.     }
  1135.       sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
  1136.       rela_hdr->sh_name =
  1137.     (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd), name,
  1138.                        true, false);
  1139.       if (rela_hdr->sh_name == (unsigned int) -1)
  1140.     {
  1141.       *failedptr = true;
  1142.       return;
  1143.     }
  1144.       rela_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
  1145.       rela_hdr->sh_entsize = (use_rela_p
  1146.                   ? bed->s->sizeof_rela
  1147.                   : bed->s->sizeof_rel);
  1148.       rela_hdr->sh_addralign = bed->s->file_align;
  1149.       rela_hdr->sh_flags = 0;
  1150.       rela_hdr->sh_addr = 0;
  1151.       rela_hdr->sh_size = 0;
  1152.       rela_hdr->sh_offset = 0;
  1153.     }
  1154. }
  1155.  
  1156. /* Assign all ELF section numbers.  The dummy first section is handled here
  1157.    too.  The link/info pointers for the standard section types are filled
  1158.    in here too, while we're at it.  */
  1159.  
  1160. static boolean
  1161. assign_section_numbers (abfd)
  1162.      bfd *abfd;
  1163. {
  1164.   struct elf_obj_tdata *t = elf_tdata (abfd);
  1165.   asection *sec;
  1166.   unsigned int section_number;
  1167.   Elf_Internal_Shdr **i_shdrp;
  1168.   struct elf_backend_data *bed = get_elf_backend_data (abfd);
  1169.  
  1170.   section_number = 1;
  1171.  
  1172.   for (sec = abfd->sections; sec; sec = sec->next)
  1173.     {
  1174.       struct bfd_elf_section_data *d = elf_section_data (sec);
  1175.  
  1176.       d->this_idx = section_number++;
  1177.       if ((sec->flags & SEC_RELOC) == 0)
  1178.     d->rel_idx = 0;
  1179.       else
  1180.     d->rel_idx = section_number++;
  1181.     }
  1182.  
  1183.   t->shstrtab_section = section_number++;
  1184.   elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
  1185.   t->shstrtab_hdr.sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
  1186.  
  1187.   if (abfd->symcount > 0)
  1188.     {
  1189.       t->symtab_section = section_number++;
  1190.       t->strtab_section = section_number++;
  1191.     }
  1192.  
  1193.   elf_elfheader (abfd)->e_shnum = section_number;
  1194.  
  1195.   /* Set up the list of section header pointers, in agreement with the
  1196.      indices.  */
  1197.   i_shdrp = ((Elf_Internal_Shdr **)
  1198.          bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *)));
  1199.   if (i_shdrp == NULL)
  1200.     return false;
  1201.  
  1202.   i_shdrp[0] = ((Elf_Internal_Shdr *)
  1203.         bfd_alloc (abfd, sizeof (Elf_Internal_Shdr)));
  1204.   if (i_shdrp[0] == NULL)
  1205.     {
  1206.       bfd_release (abfd, i_shdrp);
  1207.       return false;
  1208.     }
  1209.   memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
  1210.  
  1211.   elf_elfsections (abfd) = i_shdrp;
  1212.  
  1213.   i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
  1214.   if (abfd->symcount > 0)
  1215.     {
  1216.       i_shdrp[t->symtab_section] = &t->symtab_hdr;
  1217.       i_shdrp[t->strtab_section] = &t->strtab_hdr;
  1218.       t->symtab_hdr.sh_link = t->strtab_section;
  1219.     }
  1220.   for (sec = abfd->sections; sec; sec = sec->next)
  1221.     {
  1222.       struct bfd_elf_section_data *d = elf_section_data (sec);
  1223.       asection *s;
  1224.       const char *name;
  1225.  
  1226.       i_shdrp[d->this_idx] = &d->this_hdr;
  1227.       if (d->rel_idx != 0)
  1228.     i_shdrp[d->rel_idx] = &d->rel_hdr;
  1229.  
  1230.       /* Fill in the sh_link and sh_info fields while we're at it.  */
  1231.  
  1232.       /* sh_link of a reloc section is the section index of the symbol
  1233.      table.  sh_info is the section index of the section to which
  1234.      the relocation entries apply.  */
  1235.       if (d->rel_idx != 0)
  1236.     {
  1237.       d->rel_hdr.sh_link = t->symtab_section;
  1238.       d->rel_hdr.sh_info = d->this_idx;
  1239.     }
  1240.  
  1241.       switch (d->this_hdr.sh_type)
  1242.     {
  1243.     case SHT_REL:
  1244.     case SHT_RELA:
  1245.       /* A reloc section which we are treating as a normal BFD
  1246.          section.  sh_link is the section index of the symbol
  1247.          table.  sh_info is the section index of the section to
  1248.          which the relocation entries apply.  We assume that an
  1249.          allocated reloc section uses the dynamic symbol table.
  1250.          FIXME: How can we be sure?  */
  1251.       s = bfd_get_section_by_name (abfd, ".dynsym");
  1252.       if (s != NULL)
  1253.         d->this_hdr.sh_link = elf_section_data (s)->this_idx;
  1254.  
  1255.       /* We look up the section the relocs apply to by name.  */
  1256.       name = sec->name;
  1257.       if (d->this_hdr.sh_type == SHT_REL)
  1258.         name += 4;
  1259.       else
  1260.         name += 5;
  1261.       s = bfd_get_section_by_name (abfd, name);
  1262.       if (s != NULL)
  1263.         d->this_hdr.sh_info = elf_section_data (s)->this_idx;
  1264.       break;
  1265.  
  1266.     case SHT_STRTAB:
  1267.       /* We assume that a section named .stab*str is a stabs
  1268.          string section.  We look for a section with the same name
  1269.          but without the trailing ``str'', and set its sh_link
  1270.          field to point to this section.  */
  1271.       if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
  1272.           && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
  1273.         {
  1274.           size_t len;
  1275.           char *alc;
  1276.  
  1277.           len = strlen (sec->name);
  1278.           alc = (char *) bfd_malloc (len - 2);
  1279.           if (alc == NULL)
  1280.         return false;
  1281.           strncpy (alc, sec->name, len - 3);
  1282.           alc[len - 3] = '\0';
  1283.           s = bfd_get_section_by_name (abfd, alc);
  1284.           free (alc);
  1285.           if (s != NULL)
  1286.         {
  1287.           elf_section_data (s)->this_hdr.sh_link = d->this_idx;
  1288.  
  1289.           /* This is a .stab section.  */
  1290.           elf_section_data (s)->this_hdr.sh_entsize =
  1291.             4 + 2 * (bed->s->arch_size / 8);
  1292.         }
  1293.         }
  1294.       break;
  1295.  
  1296.     case SHT_DYNAMIC:
  1297.     case SHT_DYNSYM:
  1298.       /* sh_link is the section header index of the string table
  1299.          used for the dynamic entries or symbol table.  */
  1300.       s = bfd_get_section_by_name (abfd, ".dynstr");
  1301.       if (s != NULL)
  1302.         d->this_hdr.sh_link = elf_section_data (s)->this_idx;
  1303.       break;
  1304.  
  1305.     case SHT_HASH:
  1306.       /* sh_link is the section header index of the symbol table
  1307.          this hash table is for.  */
  1308.       s = bfd_get_section_by_name (abfd, ".dynsym");
  1309.       if (s != NULL)
  1310.         d->this_hdr.sh_link = elf_section_data (s)->this_idx;
  1311.       break;
  1312.     }
  1313.     }
  1314.  
  1315.   return true;
  1316. }
  1317.  
  1318. /* Map symbol from it's internal number to the external number, moving
  1319.    all local symbols to be at the head of the list.  */
  1320.  
  1321. static INLINE int
  1322. sym_is_global (abfd, sym)
  1323.      bfd *abfd;
  1324.      asymbol *sym;
  1325. {
  1326.   /* If the backend has a special mapping, use it.  */
  1327.   if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
  1328.     return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
  1329.         (abfd, sym));
  1330.  
  1331.   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
  1332.       || bfd_is_und_section (bfd_get_section (sym))
  1333.       || bfd_is_com_section (bfd_get_section (sym)));
  1334. }
  1335.  
  1336. static boolean
  1337. elf_map_symbols (abfd)
  1338.      bfd *abfd;
  1339. {
  1340.   int symcount = bfd_get_symcount (abfd);
  1341.   asymbol **syms = bfd_get_outsymbols (abfd);
  1342.   asymbol **sect_syms;
  1343.   int num_locals = 0;
  1344.   int num_globals = 0;
  1345.   int num_locals2 = 0;
  1346.   int num_globals2 = 0;
  1347.   int max_index = 0;
  1348.   int num_sections = 0;
  1349.   int idx;
  1350.   asection *asect;
  1351.   asymbol **new_syms;
  1352.  
  1353. #ifdef DEBUG
  1354.   fprintf (stderr, "elf_map_symbols\n");
  1355.   fflush (stderr);
  1356. #endif
  1357.  
  1358.   /* Add a section symbol for each BFD section.  FIXME: Is this really
  1359.      necessary?  */
  1360.   for (asect = abfd->sections; asect; asect = asect->next)
  1361.     {
  1362.       if (max_index < asect->index)
  1363.     max_index = asect->index;
  1364.     }
  1365.  
  1366.   max_index++;
  1367.   sect_syms = (asymbol **) bfd_zalloc (abfd, max_index * sizeof (asymbol *));
  1368.   if (sect_syms == NULL)
  1369.     return false;
  1370.   elf_section_syms (abfd) = sect_syms;
  1371.  
  1372.   for (idx = 0; idx < symcount; idx++)
  1373.     {
  1374.       if ((syms[idx]->flags & BSF_SECTION_SYM) != 0
  1375.       && (syms[idx]->value + syms[idx]->section->vma) == 0)
  1376.     {
  1377.       asection *sec;
  1378.  
  1379.       sec = syms[idx]->section;
  1380.       if (sec->owner != NULL)
  1381.         {
  1382.           if (sec->owner != abfd)
  1383.         {
  1384.           if (sec->output_offset != 0)
  1385.             continue;
  1386.           sec = sec->output_section;
  1387.           BFD_ASSERT (sec->owner == abfd);
  1388.         }
  1389.           sect_syms[sec->index] = syms[idx];
  1390.         }
  1391.     }
  1392.     }
  1393.  
  1394.   for (asect = abfd->sections; asect; asect = asect->next)
  1395.     {
  1396.       asymbol *sym;
  1397.  
  1398.       if (sect_syms[asect->index] != NULL)
  1399.     continue;
  1400.  
  1401.       sym = bfd_make_empty_symbol (abfd);
  1402.       if (sym == NULL)
  1403.     return false;
  1404.       sym->the_bfd = abfd;
  1405.       sym->name = asect->name;
  1406.       sym->value = 0;
  1407.       /* Set the flags to 0 to indicate that this one was newly added.  */
  1408.       sym->flags = 0;
  1409.       sym->section = asect;
  1410.       sect_syms[asect->index] = sym;
  1411.       num_sections++;
  1412. #ifdef DEBUG
  1413.       fprintf (stderr,
  1414.            "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
  1415.            asect->name, (long) asect->vma, asect->index, (long) asect);
  1416. #endif
  1417.     }
  1418.  
  1419.   /* Classify all of the symbols.  */
  1420.   for (idx = 0; idx < symcount; idx++)
  1421.     {
  1422.       if (!sym_is_global (abfd, syms[idx]))
  1423.     num_locals++;
  1424.       else
  1425.     num_globals++;
  1426.     }
  1427.   for (asect = abfd->sections; asect; asect = asect->next)
  1428.     {
  1429.       if (sect_syms[asect->index] != NULL
  1430.       && sect_syms[asect->index]->flags == 0)
  1431.     {
  1432.       sect_syms[asect->index]->flags = BSF_SECTION_SYM;
  1433.       if (!sym_is_global (abfd, sect_syms[asect->index]))
  1434.         num_locals++;
  1435.       else
  1436.         num_globals++;
  1437.       sect_syms[asect->index]->flags = 0;
  1438.     }
  1439.     }
  1440.  
  1441.   /* Now sort the symbols so the local symbols are first.  */
  1442.   new_syms = ((asymbol **)
  1443.           bfd_alloc (abfd,
  1444.              (num_locals + num_globals) * sizeof (asymbol *)));
  1445.   if (new_syms == NULL)
  1446.     return false;
  1447.  
  1448.   for (idx = 0; idx < symcount; idx++)
  1449.     {
  1450.       asymbol *sym = syms[idx];
  1451.       int i;
  1452.  
  1453.       if (!sym_is_global (abfd, sym))
  1454.     i = num_locals2++;
  1455.       else
  1456.     i = num_locals + num_globals2++;
  1457.       new_syms[i] = sym;
  1458.       sym->udata.i = i + 1;
  1459.     }
  1460.   for (asect = abfd->sections; asect; asect = asect->next)
  1461.     {
  1462.       if (sect_syms[asect->index] != NULL
  1463.       && sect_syms[asect->index]->flags == 0)
  1464.     {
  1465.       asymbol *sym = sect_syms[asect->index];
  1466.       int i;
  1467.  
  1468.       sym->flags = BSF_SECTION_SYM;
  1469.       if (!sym_is_global (abfd, sym))
  1470.         i = num_locals2++;
  1471.       else
  1472.         i = num_locals + num_globals2++;
  1473.       new_syms[i] = sym;
  1474.       sym->udata.i = i + 1;
  1475.     }
  1476.     }
  1477.  
  1478.   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
  1479.  
  1480.   elf_num_locals (abfd) = num_locals;
  1481.   elf_num_globals (abfd) = num_globals;
  1482.   return true;
  1483. }
  1484.  
  1485. /* Align to the maximum file alignment that could be required for any
  1486.    ELF data structure.  */
  1487.  
  1488. static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
  1489. static INLINE file_ptr
  1490. align_file_position (off, align)
  1491.      file_ptr off;
  1492.      int align;
  1493. {
  1494.   return (off + align - 1) & ~(align - 1);
  1495. }
  1496.  
  1497. /* Assign a file position to a section, optionally aligning to the
  1498.    required section alignment.  */
  1499.  
  1500. INLINE file_ptr
  1501. _bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
  1502.      Elf_Internal_Shdr *i_shdrp;
  1503.      file_ptr offset;
  1504.      boolean align;
  1505. {
  1506.   if (align)
  1507.     {
  1508.       unsigned int al;
  1509.  
  1510.       al = i_shdrp->sh_addralign;
  1511.       if (al > 1)
  1512.     offset = BFD_ALIGN (offset, al);
  1513.     }
  1514.   i_shdrp->sh_offset = offset;
  1515.   if (i_shdrp->bfd_section != NULL)
  1516.     i_shdrp->bfd_section->filepos = offset;
  1517.   if (i_shdrp->sh_type != SHT_NOBITS)
  1518.     offset += i_shdrp->sh_size;
  1519.   return offset;
  1520. }
  1521.  
  1522. /* Compute the file positions we are going to put the sections at, and
  1523.    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
  1524.    is not NULL, this is being called by the ELF backend linker.  */
  1525.  
  1526. boolean
  1527. _bfd_elf_compute_section_file_positions (abfd, link_info)
  1528.      bfd *abfd;
  1529.      struct bfd_link_info *link_info;
  1530. {
  1531.   struct elf_backend_data *bed = get_elf_backend_data (abfd);
  1532.   boolean failed;
  1533.   struct bfd_strtab_hash *strtab;
  1534.   Elf_Internal_Shdr *shstrtab_hdr;
  1535.  
  1536.   if (abfd->output_has_begun)
  1537.     return true;
  1538.  
  1539.   /* Do any elf backend specific processing first.  */
  1540.   if (bed->elf_backend_begin_write_processing)
  1541.     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
  1542.  
  1543.   if (! prep_headers (abfd))
  1544.     return false;
  1545.  
  1546.   failed = false;
  1547.   bfd_map_over_sections (abfd, elf_fake_sections, &failed);
  1548.   if (failed)
  1549.     return false;
  1550.  
  1551.   if (!assign_section_numbers (abfd))
  1552.     return false;
  1553.  
  1554.   /* The backend linker builds symbol table information itself.  */
  1555.   if (link_info == NULL && abfd->symcount > 0)
  1556.     {
  1557.       if (! swap_out_syms (abfd, &strtab))
  1558.     return false;
  1559.     }
  1560.  
  1561.   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
  1562.   /* sh_name was set in prep_headers.  */
  1563.   shstrtab_hdr->sh_type = SHT_STRTAB;
  1564.   shstrtab_hdr->sh_flags = 0;
  1565.   shstrtab_hdr->sh_addr = 0;
  1566.   shstrtab_hdr->sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
  1567.   shstrtab_hdr->sh_entsize = 0;
  1568.   shstrtab_hdr->sh_link = 0;
  1569.   shstrtab_hdr->sh_info = 0;
  1570.   /* sh_offset is set in assign_file_positions_except_relocs.  */
  1571.   shstrtab_hdr->sh_addralign = 1;
  1572.  
  1573.   if (!assign_file_positions_except_relocs (abfd))
  1574.     return false;
  1575.  
  1576.   if (link_info == NULL && abfd->symcount > 0)
  1577.     {
  1578.       file_ptr off;
  1579.       Elf_Internal_Shdr *hdr;
  1580.  
  1581.       off = elf_tdata (abfd)->next_file_pos;
  1582.  
  1583.       hdr = &elf_tdata (abfd)->symtab_hdr;
  1584.       off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
  1585.  
  1586.       hdr = &elf_tdata (abfd)->strtab_hdr;
  1587.       off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
  1588.  
  1589.       elf_tdata (abfd)->next_file_pos = off;
  1590.  
  1591.       /* Now that we know where the .strtab section goes, write it
  1592.          out.  */
  1593.       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
  1594.       || ! _bfd_stringtab_emit (abfd, strtab))
  1595.     return false;
  1596.       _bfd_stringtab_free (strtab);
  1597.     }
  1598.  
  1599.   abfd->output_has_begun = true;
  1600.  
  1601.   return true;
  1602. }
  1603.  
  1604. /* Create a mapping from a set of sections to a program segment.  */
  1605.  
  1606. static INLINE struct elf_segment_map *
  1607. make_mapping (abfd, sections, from, to, phdr)
  1608.      bfd *abfd;
  1609.      asection **sections;
  1610.      unsigned int from;
  1611.      unsigned int to;
  1612.      boolean phdr;
  1613. {
  1614.   struct elf_segment_map *m;
  1615.   unsigned int i;
  1616.   asection **hdrpp;
  1617.  
  1618.   m = ((struct elf_segment_map *)
  1619.        bfd_zalloc (abfd,
  1620.            (sizeof (struct elf_segment_map)
  1621.             + (to - from - 1) * sizeof (asection *))));
  1622.   if (m == NULL)
  1623.     return NULL;
  1624.   m->next = NULL;
  1625.   m->p_type = PT_LOAD;
  1626.   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
  1627.     m->sections[i - from] = *hdrpp;
  1628.   m->count = to - from;
  1629.  
  1630.   if (from == 0 && phdr)
  1631.     {
  1632.       /* Include the headers in the first PT_LOAD segment.  */
  1633.       m->includes_filehdr = 1;
  1634.       m->includes_phdrs = 1;
  1635.     }
  1636.  
  1637.   return m;
  1638. }
  1639.  
  1640. /* Set up a mapping from BFD sections to program segments.  */
  1641.  
  1642. static boolean
  1643. map_sections_to_segments (abfd)
  1644.      bfd *abfd;
  1645. {
  1646.   asection **sections = NULL;
  1647.   asection *s;
  1648.   unsigned int i;
  1649.   unsigned int count;
  1650.   struct elf_segment_map *mfirst;
  1651.   struct elf_segment_map **pm;
  1652.   struct elf_segment_map *m;
  1653.   asection *last_hdr;
  1654.   unsigned int phdr_index;
  1655.   bfd_vma maxpagesize;
  1656.   asection **hdrpp;
  1657.   boolean phdr_in_section = true;
  1658.   boolean writable;
  1659.   asection *dynsec;
  1660.  
  1661.   if (elf_tdata (abfd)->segment_map != NULL)
  1662.     return true;
  1663.  
  1664.   if (bfd_count_sections (abfd) == 0)
  1665.     return true;
  1666.  
  1667.   /* Select the allocated sections, and sort them.  */
  1668.  
  1669.   sections = (asection **) bfd_malloc (bfd_count_sections (abfd)
  1670.                        * sizeof (asection *));
  1671.   if (sections == NULL)
  1672.     goto error_return;
  1673.  
  1674.   i = 0;
  1675.   for (s = abfd->sections; s != NULL; s = s->next)
  1676.     {
  1677.       if ((s->flags & SEC_ALLOC) != 0)
  1678.     {
  1679.       sections[i] = s;
  1680.       ++i;
  1681.     }
  1682.     }
  1683.   BFD_ASSERT (i <= bfd_count_sections (abfd));
  1684.   count = i;
  1685.  
  1686.   qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
  1687.  
  1688.   /* Build the mapping.  */
  1689.  
  1690.   mfirst = NULL;
  1691.   pm = &mfirst;
  1692.  
  1693.   /* If we have a .interp section, then create a PT_PHDR segment for
  1694.      the program headers and a PT_INTERP segment for the .interp
  1695.      section.  */
  1696.   s = bfd_get_section_by_name (abfd, ".interp");
  1697.   if (s != NULL && (s->flags & SEC_LOAD) != 0)
  1698.     {
  1699.       m = ((struct elf_segment_map *)
  1700.        bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
  1701.       if (m == NULL)
  1702.     goto error_return;
  1703.       m->next = NULL;
  1704.       m->p_type = PT_PHDR;
  1705.       /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
  1706.       m->p_flags = PF_R | PF_X;
  1707.       m->p_flags_valid = 1;
  1708.       m->includes_phdrs = 1;
  1709.  
  1710.       *pm = m;
  1711.       pm = &m->next;
  1712.  
  1713.       m = ((struct elf_segment_map *)
  1714.        bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
  1715.       if (m == NULL)
  1716.     goto error_return;
  1717.       m->next = NULL;
  1718.       m->p_type = PT_INTERP;
  1719.       m->count = 1;
  1720.       m->sections[0] = s;
  1721.  
  1722.       *pm = m;
  1723.       pm = &m->next;
  1724.     }
  1725.  
  1726.   /* Look through the sections.  We put sections in the same program
  1727.      segment when the start of the second section can be placed within
  1728.      a few bytes of the end of the first section.  */
  1729.   last_hdr = NULL;
  1730.   phdr_index = 0;
  1731.   maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
  1732.   writable = false;
  1733.   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
  1734.   if (dynsec != NULL
  1735.       && (dynsec->flags & SEC_LOAD) == 0)
  1736.     dynsec = NULL;
  1737.  
  1738.   /* Deal with -Ttext or something similar such that the first section
  1739.      is not adjacent to the program headers.  This is an
  1740.      approximation, since at this point we don't know exactly how many
  1741.      program headers we will need.  */
  1742.   if (count > 0)
  1743.     {
  1744.       bfd_size_type phdr_size;
  1745.  
  1746.       phdr_size = elf_tdata (abfd)->program_header_size;
  1747.       if (phdr_size == 0)
  1748.     phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
  1749.       if (sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
  1750.     phdr_in_section = false;
  1751.     }
  1752.  
  1753.   for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
  1754.     {
  1755.       asection *hdr;
  1756.  
  1757.       hdr = *hdrpp;
  1758.  
  1759.       /* See if this section and the last one will fit in the same
  1760.          segment.  Don't put a loadable section after a non-loadable
  1761.          section.  If we are building a dynamic executable, don't put
  1762.          a writable section in a read only segment, unless they're on
  1763.          the same page anyhow (we don't do this for a non-dynamic
  1764.          executable because some people prefer to have only one
  1765.          program segment; anybody can use PHDRS in their linker script
  1766.          to control what happens anyhow).  */
  1767.       if (last_hdr == NULL
  1768.       || ((BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
  1769.            >= hdr->lma)
  1770.           && ((last_hdr->flags & SEC_LOAD) != 0
  1771.           || (hdr->flags & SEC_LOAD) == 0)
  1772.           && (dynsec == NULL
  1773.           || writable
  1774.           || (hdr->flags & SEC_READONLY) != 0
  1775.           || (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size,
  1776.                  maxpagesize)
  1777.               > hdr->lma))))
  1778.               
  1779.     {
  1780.       if ((hdr->flags & SEC_READONLY) == 0)
  1781.         writable = true;
  1782.       last_hdr = hdr;
  1783.       continue;
  1784.     }
  1785.  
  1786.       /* This section won't fit in the program segment.  We must
  1787.          create a new program header holding all the sections from
  1788.          phdr_index until hdr.  */
  1789.  
  1790.       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_section);
  1791.       if (m == NULL)
  1792.     goto error_return;
  1793.  
  1794.       *pm = m;
  1795.       pm = &m->next;
  1796.  
  1797.       if ((hdr->flags & SEC_READONLY) == 0)
  1798.     writable = true;
  1799.       else
  1800.     writable = false;
  1801.  
  1802.       last_hdr = hdr;
  1803.       phdr_index = i;
  1804.       phdr_in_section = false;
  1805.     }
  1806.  
  1807.   /* Create a final PT_LOAD program segment.  */
  1808.   if (last_hdr != NULL)
  1809.     {
  1810.       m = make_mapping (abfd, sections, phdr_index, i, phdr_in_section);
  1811.       if (m == NULL)
  1812.     goto error_return;
  1813.  
  1814.       *pm = m;
  1815.       pm = &m->next;
  1816.     }
  1817.  
  1818.   /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
  1819.   if (dynsec != NULL)
  1820.     {
  1821.       m = ((struct elf_segment_map *)
  1822.        bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
  1823.       if (m == NULL)
  1824.     goto error_return;
  1825.       m->next = NULL;
  1826.       m->p_type = PT_DYNAMIC;
  1827.       m->count = 1;
  1828.       m->sections[0] = dynsec;
  1829.  
  1830.       *pm = m;
  1831.       pm = &m->next;
  1832.     }
  1833.  
  1834.   free (sections);
  1835.   sections = NULL;
  1836.  
  1837.   elf_tdata (abfd)->segment_map = mfirst;
  1838.   return true;
  1839.  
  1840.  error_return:
  1841.   if (sections != NULL)
  1842.     free (sections);
  1843.   return false;
  1844. }
  1845.  
  1846. /* Sort sections by VMA.  */
  1847.  
  1848. static int
  1849. elf_sort_sections (arg1, arg2)
  1850.      const PTR arg1;
  1851.      const PTR arg2;
  1852. {
  1853.   const asection *sec1 = *(const asection **) arg1;
  1854.   const asection *sec2 = *(const asection **) arg2;
  1855.  
  1856.   if (sec1->vma < sec2->vma)
  1857.     return -1;
  1858.   else if (sec1->vma > sec2->vma)
  1859.     return 1;
  1860.  
  1861.   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
  1862.  
  1863. #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
  1864.  
  1865.   if (TOEND (sec1))
  1866.     if (TOEND (sec2))
  1867.       return sec1->target_index - sec2->target_index;
  1868.     else 
  1869.       return 1;
  1870.  
  1871.   if (TOEND (sec2))
  1872.     return -1;
  1873.  
  1874. #undef TOEND
  1875.  
  1876.   /* Sort by size, to put zero sized sections before others at the
  1877.      same address.  */
  1878.  
  1879.   if (sec1->_raw_size < sec2->_raw_size)
  1880.     return -1;
  1881.   if (sec1->_raw_size > sec2->_raw_size)
  1882.     return 1;
  1883.  
  1884.   return sec1->target_index - sec2->target_index;
  1885. }
  1886.  
  1887. /* Assign file positions to the sections based on the mapping from
  1888.    sections to segments.  This function also sets up some fields in
  1889.    the file header, and writes out the program headers.  */
  1890.  
  1891. static boolean
  1892. assign_file_positions_for_segments (abfd)
  1893.      bfd *abfd;
  1894. {
  1895.   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
  1896.   unsigned int count;
  1897.   struct elf_segment_map *m;
  1898.   unsigned int alloc;
  1899.   Elf_Internal_Phdr *phdrs;
  1900.   file_ptr off;
  1901.   bfd_vma filehdr_vaddr, filehdr_paddr;
  1902.   bfd_vma phdrs_vaddr, phdrs_paddr;
  1903.   Elf_Internal_Phdr *p;
  1904.  
  1905.   if (elf_tdata (abfd)->segment_map == NULL)
  1906.     {
  1907.       if (! map_sections_to_segments (abfd))
  1908.     return false;
  1909.     }
  1910.  
  1911.   if (bed->elf_backend_modify_segment_map)
  1912.     {
  1913.       if (! (*bed->elf_backend_modify_segment_map) (abfd))
  1914.     return false;
  1915.     }
  1916.  
  1917.   count = 0;
  1918.   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
  1919.     ++count;
  1920.  
  1921.   elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
  1922.   elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
  1923.   elf_elfheader (abfd)->e_phnum = count;
  1924.  
  1925.   if (count == 0)
  1926.     return true;
  1927.  
  1928.   /* If we already counted the number of program segments, make sure
  1929.      that we allocated enough space.  This happens when SIZEOF_HEADERS
  1930.      is used in a linker script.  */
  1931.   alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
  1932.   if (alloc != 0 && count > alloc)
  1933.     {
  1934.       ((*_bfd_error_handler)
  1935.        ("%s: Not enough room for program headers (allocated %u, need %u)",
  1936.     bfd_get_filename (abfd), alloc, count));
  1937.       bfd_set_error (bfd_error_bad_value);
  1938.       return false;
  1939.     }
  1940.  
  1941.   if (alloc == 0)
  1942.     alloc = count;
  1943.  
  1944.   phdrs = ((Elf_Internal_Phdr *)
  1945.        bfd_alloc (abfd, alloc * sizeof (Elf_Internal_Phdr)));
  1946.   if (phdrs == NULL)
  1947.     return false;
  1948.  
  1949.   off = bed->s->sizeof_ehdr;
  1950.   off += alloc * bed->s->sizeof_phdr;
  1951.  
  1952.   filehdr_vaddr = 0;
  1953.   filehdr_paddr = 0;
  1954.   phdrs_vaddr = 0;
  1955.   phdrs_paddr = 0;
  1956.   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
  1957.        m != NULL;
  1958.        m = m->next, p++)
  1959.     {
  1960.       unsigned int i;
  1961.       asection **secpp;
  1962.  
  1963.       /* If elf_segment_map is not from map_sections_to_segments, the
  1964.          sections may not be correctly ordered.  */
  1965.       if (m->count > 0)
  1966.     qsort (m->sections, (size_t) m->count, sizeof (asection *),
  1967.            elf_sort_sections);
  1968.  
  1969.       p->p_type = m->p_type;
  1970.  
  1971.       if (m->p_flags_valid)
  1972.     p->p_flags = m->p_flags;
  1973.       else
  1974.     p->p_flags = 0;
  1975.  
  1976.       if (p->p_type == PT_LOAD
  1977.       && m->count > 0
  1978.       && (m->sections[0]->flags & SEC_LOAD) != 0)
  1979.     off += (m->sections[0]->vma - off) % bed->maxpagesize;
  1980.  
  1981.       if (m->count == 0)
  1982.     p->p_vaddr = 0;
  1983.       else
  1984.     p->p_vaddr = m->sections[0]->vma;
  1985.  
  1986.       if (m->p_paddr_valid)
  1987.     p->p_paddr = m->p_paddr;
  1988.       else if (m->count == 0)
  1989.     p->p_paddr = 0;
  1990.       else
  1991.     p->p_paddr = m->sections[0]->lma;
  1992.  
  1993.       if (p->p_type == PT_LOAD)
  1994.     p->p_align = bed->maxpagesize;
  1995.       else if (m->count == 0)
  1996.     p->p_align = bed->s->file_align;
  1997.       else
  1998.     p->p_align = 0;
  1999.  
  2000.       p->p_offset = 0;
  2001.       p->p_filesz = 0;
  2002.       p->p_memsz = 0;
  2003.  
  2004.       if (m->includes_filehdr)
  2005.     {
  2006.       if (! m->p_flags_valid)
  2007.         p->p_flags |= PF_R;
  2008.       p->p_offset = 0;
  2009.       p->p_filesz = bed->s->sizeof_ehdr;
  2010.       p->p_memsz = bed->s->sizeof_ehdr;
  2011.       if (m->count > 0)
  2012.         {
  2013.           BFD_ASSERT (p->p_type == PT_LOAD);
  2014.           p->p_vaddr -= off;
  2015.           if (! m->p_paddr_valid)
  2016.         p->p_paddr -= off;
  2017.         }
  2018.       if (p->p_type == PT_LOAD)
  2019.         {
  2020.           filehdr_vaddr = p->p_vaddr;
  2021.           filehdr_paddr = p->p_paddr;
  2022.         }
  2023.     }
  2024.  
  2025.       if (m->includes_phdrs)
  2026.     {
  2027.       if (! m->p_flags_valid)
  2028.         p->p_flags |= PF_R;
  2029.       if (m->includes_filehdr)
  2030.         {
  2031.           if (p->p_type == PT_LOAD)
  2032.         {
  2033.           phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
  2034.           phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
  2035.         }
  2036.         }
  2037.       else
  2038.         {
  2039.           p->p_offset = bed->s->sizeof_ehdr;
  2040.           if (m->count > 0)
  2041.         {
  2042.           BFD_ASSERT (p->p_type == PT_LOAD);
  2043.           p->p_vaddr -= off - p->p_offset;
  2044.           if (! m->p_paddr_valid)
  2045.             p->p_paddr -= off - p->p_offset;
  2046.         }
  2047.           if (p->p_type == PT_LOAD)
  2048.         {
  2049.           phdrs_vaddr = p->p_vaddr;
  2050.           phdrs_paddr = p->p_paddr;
  2051.         }
  2052.         }
  2053.       p->p_filesz += alloc * bed->s->sizeof_phdr;
  2054.       p->p_memsz += alloc * bed->s->sizeof_phdr;
  2055.     }
  2056.  
  2057.       if (p->p_type == PT_LOAD)
  2058.     {
  2059.       if (! m->includes_filehdr && ! m->includes_phdrs)
  2060.         p->p_offset = off;
  2061.       else
  2062.         {
  2063.           file_ptr adjust;
  2064.  
  2065.           adjust = off - (p->p_offset + p->p_filesz);
  2066.           p->p_filesz += adjust;
  2067.           p->p_memsz += adjust;
  2068.         }
  2069.     }
  2070.  
  2071.       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
  2072.     {
  2073.       asection *sec;
  2074.       flagword flags;
  2075.       bfd_size_type align;
  2076.  
  2077.       sec = *secpp;
  2078.       flags = sec->flags;
  2079.  
  2080.       if (p->p_type == PT_LOAD)
  2081.         {
  2082.           bfd_vma adjust;
  2083.  
  2084.           /* The section VMA must equal the file position modulo
  2085.                  the page size.  */
  2086.           if ((flags & SEC_ALLOC) != 0)
  2087.         {
  2088.           adjust = (sec->vma - off) % bed->maxpagesize;
  2089.           if (adjust != 0)
  2090.             {
  2091.               if (i == 0)
  2092.             abort ();
  2093.               p->p_memsz += adjust;
  2094.               off += adjust;
  2095.               if ((flags & SEC_LOAD) != 0)
  2096.             p->p_filesz += adjust;
  2097.             }
  2098.         }
  2099.  
  2100.           sec->filepos = off;
  2101.  
  2102.           if ((flags & SEC_LOAD) != 0)
  2103.         off += sec->_raw_size;
  2104.         }
  2105.  
  2106.       p->p_memsz += sec->_raw_size;
  2107.  
  2108.       if ((flags & SEC_LOAD) != 0)
  2109.         p->p_filesz += sec->_raw_size;
  2110.  
  2111.       align = 1 << bfd_get_section_alignment (abfd, sec);
  2112.       if (align > p->p_align)
  2113.         p->p_align = align;
  2114.  
  2115.       if (! m->p_flags_valid)
  2116.         {
  2117.           p->p_flags |= PF_R;
  2118.           if ((flags & SEC_CODE) != 0)
  2119.         p->p_flags |= PF_X;
  2120.           if ((flags & SEC_READONLY) == 0)
  2121.         p->p_flags |= PF_W;
  2122.         }
  2123.     }
  2124.     }
  2125.  
  2126.   /* Now that we have set the section file positions, we can set up
  2127.      the file positions for the non PT_LOAD segments.  */
  2128.   for (m = elf_tdata (abfd)->segment_map, p = phdrs;
  2129.        m != NULL;
  2130.        m = m->next, p++)
  2131.     {
  2132.       if (p->p_type != PT_LOAD && m->count > 0)
  2133.     {
  2134.       BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
  2135.       p->p_offset = m->sections[0]->filepos;
  2136.     }
  2137.       if (m->count == 0)
  2138.     {
  2139.       if (m->includes_filehdr)
  2140.         {
  2141.           p->p_vaddr = filehdr_vaddr;
  2142.           if (! m->p_paddr_valid)
  2143.         p->p_paddr = filehdr_paddr;
  2144.         }
  2145.       else if (m->includes_phdrs)
  2146.         {
  2147.           p->p_vaddr = phdrs_vaddr;
  2148.           if (! m->p_paddr_valid)
  2149.         p->p_paddr = phdrs_paddr;
  2150.         }
  2151.     }
  2152.     }
  2153.  
  2154.   /* Clear out any program headers we allocated but did not use.  */
  2155.   for (; count < alloc; count++, p++)
  2156.     {
  2157.       memset (p, 0, sizeof *p);
  2158.       p->p_type = PT_NULL;
  2159.     }
  2160.  
  2161.   elf_tdata (abfd)->phdr = phdrs;
  2162.  
  2163.   elf_tdata (abfd)->next_file_pos = off;
  2164.  
  2165.   /* Write out the program headers.  */
  2166.   if (bfd_seek (abfd, bed->s->sizeof_ehdr, SEEK_SET) != 0
  2167.       || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
  2168.     return false;
  2169.  
  2170.   return true;
  2171. }
  2172.  
  2173. /* Get the size of the program header.
  2174.  
  2175.    If this is called by the linker before any of the section VMA's are set, it
  2176.    can't calculate the correct value for a strange memory layout.  This only
  2177.    happens when SIZEOF_HEADERS is used in a linker script.  In this case,
  2178.    SORTED_HDRS is NULL and we assume the normal scenario of one text and one
  2179.    data segment (exclusive of .interp and .dynamic).
  2180.  
  2181.    ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
  2182.    will be two segments.  */
  2183.  
  2184. static bfd_size_type
  2185. get_program_header_size (abfd)
  2186.      bfd *abfd;
  2187. {
  2188.   size_t segs;
  2189.   asection *s;
  2190.   struct elf_backend_data *bed = get_elf_backend_data (abfd);
  2191.  
  2192.   /* We can't return a different result each time we're called.  */
  2193.   if (elf_tdata (abfd)->program_header_size != 0)
  2194.     return elf_tdata (abfd)->program_header_size;
  2195.  
  2196.   if (elf_tdata (abfd)->segment_map != NULL)
  2197.     {
  2198.       struct elf_segment_map *m;
  2199.  
  2200.       segs = 0;
  2201.       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
  2202.     ++segs;
  2203.       elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
  2204.       return elf_tdata (abfd)->program_header_size;
  2205.     }
  2206.  
  2207.   /* Assume we will need exactly two PT_LOAD segments: one for text
  2208.      and one for data.  */
  2209.   segs = 2;
  2210.  
  2211.   s = bfd_get_section_by_name (abfd, ".interp");
  2212.   if (s != NULL && (s->flags & SEC_LOAD) != 0)
  2213.     {
  2214.       /* If we have a loadable interpreter section, we need a
  2215.      PT_INTERP segment.  In this case, assume we also need a
  2216.      PT_PHDR segment, although that may not be true for all
  2217.      targets.  */
  2218.       segs += 2;
  2219.     }
  2220.  
  2221.   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
  2222.     {
  2223.       /* We need a PT_DYNAMIC segment.  */
  2224.       ++segs;
  2225.     }
  2226.  
  2227.   /* Let the backend count up any program headers it might need.  */
  2228.   if (bed->elf_backend_additional_program_headers)
  2229.     {
  2230.       int a;
  2231.  
  2232.       a = (*bed->elf_backend_additional_program_headers) (abfd);
  2233.       if (a == -1)
  2234.     abort ();
  2235.       segs += a;
  2236.     }
  2237.  
  2238.   elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
  2239.   return elf_tdata (abfd)->program_header_size;
  2240. }
  2241.  
  2242. /* Work out the file positions of all the sections.  This is called by
  2243.    _bfd_elf_compute_section_file_positions.  All the section sizes and
  2244.    VMAs must be known before this is called.
  2245.  
  2246.    We do not consider reloc sections at this point, unless they form
  2247.    part of the loadable image.  Reloc sections are assigned file
  2248.    positions in assign_file_positions_for_relocs, which is called by
  2249.    write_object_contents and final_link.
  2250.  
  2251.    We also don't set the positions of the .symtab and .strtab here.  */
  2252.  
  2253. static boolean
  2254. assign_file_positions_except_relocs (abfd)
  2255.      bfd *abfd;
  2256. {
  2257.   struct elf_obj_tdata * const tdata = elf_tdata (abfd);
  2258.   Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
  2259.   Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
  2260.   file_ptr off;
  2261.   struct elf_backend_data *bed = get_elf_backend_data (abfd);
  2262.  
  2263.   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
  2264.     {
  2265.       Elf_Internal_Shdr **hdrpp;
  2266.       unsigned int i;
  2267.  
  2268.       /* Start after the ELF header.  */
  2269.       off = i_ehdrp->e_ehsize;
  2270.  
  2271.       /* We are not creating an executable, which means that we are
  2272.      not creating a program header, and that the actual order of
  2273.      the sections in the file is unimportant.  */
  2274.       for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
  2275.     {
  2276.       Elf_Internal_Shdr *hdr;
  2277.  
  2278.       hdr = *hdrpp;
  2279.       if (hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
  2280.         {
  2281.           hdr->sh_offset = -1;
  2282.           continue;
  2283.         }
  2284.       if (i == tdata->symtab_section
  2285.           || i == tdata->strtab_section)
  2286.         {
  2287.           hdr->sh_offset = -1;
  2288.           continue;
  2289.         }
  2290.       
  2291.       off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
  2292.     }
  2293.     }
  2294.   else
  2295.     {
  2296.       unsigned int i;
  2297.       Elf_Internal_Shdr **hdrpp;
  2298.  
  2299.       /* Assign file positions for the loaded sections based on the
  2300.          assignment of sections to segments.  */
  2301.       if (! assign_file_positions_for_segments (abfd))
  2302.     return false;
  2303.  
  2304.       /* Assign file positions for the other sections.  */
  2305.  
  2306.       off = elf_tdata (abfd)->next_file_pos;
  2307.       for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
  2308.     {
  2309.       Elf_Internal_Shdr *hdr;
  2310.  
  2311.       hdr = *hdrpp;
  2312.       if (hdr->bfd_section != NULL
  2313.           && hdr->bfd_section->filepos != 0)
  2314.         hdr->sh_offset = hdr->bfd_section->filepos;
  2315.       else if ((hdr->sh_flags & SHF_ALLOC) != 0)
  2316.         {
  2317.           ((*_bfd_error_handler)
  2318.            ("%s: warning: allocated section `%s' not in segment",
  2319.         bfd_get_filename (abfd),
  2320.         (hdr->bfd_section == NULL
  2321.          ? "*unknown*"
  2322.          : hdr->bfd_section->name)));
  2323.           off += (hdr->sh_addr - off) % bed->maxpagesize;
  2324.           off = _bfd_elf_assign_file_position_for_section (hdr, off,
  2325.                                    false);
  2326.         }
  2327.       else if (hdr->sh_type == SHT_REL
  2328.            || hdr->sh_type == SHT_RELA
  2329.            || hdr == i_shdrpp[tdata->symtab_section]
  2330.            || hdr == i_shdrpp[tdata->strtab_section])
  2331.         hdr->sh_offset = -1;
  2332.       else
  2333.         off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
  2334.     }           
  2335.     }
  2336.  
  2337.   /* Place the section headers.  */
  2338.   off = align_file_position (off, bed->s->file_align);
  2339.   i_ehdrp->e_shoff = off;
  2340.   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
  2341.  
  2342.   elf_tdata (abfd)->next_file_pos = off;
  2343.  
  2344.   return true;
  2345. }
  2346.  
  2347. static boolean
  2348. prep_headers (abfd)
  2349.      bfd *abfd;
  2350. {
  2351.   Elf_Internal_Ehdr *i_ehdrp;    /* Elf file header, internal form */
  2352.   Elf_Internal_Phdr *i_phdrp = 0;    /* Program header table, internal form */
  2353.   Elf_Internal_Shdr **i_shdrp;    /* Section header table, internal form */
  2354.   int count;
  2355.   struct bfd_strtab_hash *shstrtab;
  2356.   struct elf_backend_data *bed = get_elf_backend_data (abfd);
  2357.  
  2358.   i_ehdrp = elf_elfheader (abfd);
  2359.   i_shdrp = elf_elfsections (abfd);
  2360.  
  2361.   shstrtab = _bfd_elf_stringtab_init ();
  2362.   if (shstrtab == NULL)
  2363.     return false;
  2364.  
  2365.   elf_shstrtab (abfd) = shstrtab;
  2366.  
  2367.   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
  2368.   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
  2369.   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
  2370.   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
  2371.  
  2372.   i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
  2373.   i_ehdrp->e_ident[EI_DATA] =
  2374.     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
  2375.   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
  2376.  
  2377.   for (count = EI_PAD; count < EI_NIDENT; count++)
  2378.     i_ehdrp->e_ident[count] = 0;
  2379.  
  2380.   if ((abfd->flags & DYNAMIC) != 0)
  2381.     i_ehdrp->e_type = ET_DYN;
  2382.   else if ((abfd->flags & EXEC_P) != 0)
  2383.     i_ehdrp->e_type = ET_EXEC;
  2384.   else
  2385.     i_ehdrp->e_type = ET_REL;
  2386.  
  2387.   switch (bfd_get_arch (abfd))
  2388.     {
  2389.     case bfd_arch_unknown:
  2390.       i_ehdrp->e_machine = EM_NONE;
  2391.       break;
  2392.     case bfd_arch_sparc:
  2393.       if (bed->s->arch_size == 64)
  2394.     i_ehdrp->e_machine = EM_SPARC64;
  2395.       else
  2396.     i_ehdrp->e_machine = EM_SPARC;
  2397.       break;
  2398.     case bfd_arch_i386:
  2399.       i_ehdrp->e_machine = EM_386;
  2400.       break;
  2401.     case bfd_arch_m68k:
  2402.       i_ehdrp->e_machine = EM_68K;
  2403.       break;
  2404.     case bfd_arch_m88k:
  2405.       i_ehdrp->e_machine = EM_88K;
  2406.       break;
  2407.     case bfd_arch_i860:
  2408.       i_ehdrp->e_machine = EM_860;
  2409.       break;
  2410.     case bfd_arch_mips:    /* MIPS Rxxxx */
  2411.       i_ehdrp->e_machine = EM_MIPS;    /* only MIPS R3000 */
  2412.       break;
  2413.     case bfd_arch_hppa:
  2414.       i_ehdrp->e_machine = EM_PARISC;
  2415.       break;
  2416.     case bfd_arch_powerpc:
  2417.       i_ehdrp->e_machine = EM_PPC;
  2418.       break;
  2419.     case bfd_arch_alpha:
  2420.       i_ehdrp->e_machine = EM_ALPHA;
  2421.       break;
  2422.       /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
  2423.     default:
  2424.       i_ehdrp->e_machine = EM_NONE;
  2425.     }
  2426.   i_ehdrp->e_version = bed->s->ev_current;
  2427.   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
  2428.  
  2429.   /* no program header, for now. */
  2430.   i_ehdrp->e_phoff = 0;
  2431.   i_ehdrp->e_phentsize = 0;
  2432.   i_ehdrp->e_phnum = 0;
  2433.  
  2434.   /* each bfd section is section header entry */
  2435.   i_ehdrp->e_entry = bfd_get_start_address (abfd);
  2436.   i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
  2437.  
  2438.   /* if we're building an executable, we'll need a program header table */
  2439.   if (abfd->flags & EXEC_P)
  2440.     {
  2441.       /* it all happens later */
  2442. #if 0
  2443.       i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
  2444.  
  2445.       /* elf_build_phdrs() returns a (NULL-terminated) array of
  2446.      Elf_Internal_Phdrs */
  2447.       i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
  2448.       i_ehdrp->e_phoff = outbase;
  2449.       outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
  2450. #endif
  2451.     }
  2452.   else
  2453.     {
  2454.       i_ehdrp->e_phentsize = 0;
  2455.       i_phdrp = 0;
  2456.       i_ehdrp->e_phoff = 0;
  2457.     }
  2458.  
  2459.   elf_tdata (abfd)->symtab_hdr.sh_name =
  2460.     (unsigned int) _bfd_stringtab_add (shstrtab, ".symtab", true, false);
  2461.   elf_tdata (abfd)->strtab_hdr.sh_name =
  2462.     (unsigned int) _bfd_stringtab_add (shstrtab, ".strtab", true, false);
  2463.   elf_tdata (abfd)->shstrtab_hdr.sh_name =
  2464.     (unsigned int) _bfd_stringtab_add (shstrtab, ".shstrtab", true, false);
  2465.   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
  2466.       || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
  2467.       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
  2468.     return false;
  2469.  
  2470.   return true;
  2471. }
  2472.  
  2473. /* Assign file positions for all the reloc sections which are not part
  2474.    of the loadable file image.  */
  2475.  
  2476. void
  2477. _bfd_elf_assign_file_positions_for_relocs (abfd)
  2478.      bfd *abfd;
  2479. {
  2480.   file_ptr off;
  2481.   unsigned int i;
  2482.   Elf_Internal_Shdr **shdrpp;
  2483.  
  2484.   off = elf_tdata (abfd)->next_file_pos;
  2485.  
  2486.   for (i = 1, shdrpp = elf_elfsections (abfd) + 1;
  2487.        i < elf_elfheader (abfd)->e_shnum;
  2488.        i++, shdrpp++)
  2489.     {
  2490.       Elf_Internal_Shdr *shdrp;
  2491.  
  2492.       shdrp = *shdrpp;
  2493.       if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
  2494.       && shdrp->sh_offset == -1)
  2495.     off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
  2496.     }
  2497.  
  2498.   elf_tdata (abfd)->next_file_pos = off;
  2499. }
  2500.  
  2501. boolean
  2502. _bfd_elf_write_object_contents (abfd)
  2503.      bfd *abfd;
  2504. {
  2505.   struct elf_backend_data *bed = get_elf_backend_data (abfd);
  2506.   Elf_Internal_Ehdr *i_ehdrp;
  2507.   Elf_Internal_Shdr **i_shdrp;
  2508.   boolean failed;
  2509.   unsigned int count;
  2510.  
  2511.   if (! abfd->output_has_begun
  2512.       && ! _bfd_elf_compute_section_file_positions (abfd,
  2513.                             (struct bfd_link_info *) NULL))
  2514.     return false;
  2515.  
  2516.   i_shdrp = elf_elfsections (abfd);
  2517.   i_ehdrp = elf_elfheader (abfd);
  2518.  
  2519.   failed = false;
  2520.   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
  2521.   if (failed)
  2522.     return false;
  2523.   _bfd_elf_assign_file_positions_for_relocs (abfd);
  2524.  
  2525.   /* After writing the headers, we need to write the sections too... */
  2526.   for (count = 1; count < i_ehdrp->e_shnum; count++)
  2527.     {
  2528.       if (bed->elf_backend_section_processing)
  2529.     (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
  2530.       if (i_shdrp[count]->contents)
  2531.     {
  2532.       if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
  2533.           || (bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size,
  2534.                  1, abfd)
  2535.           != i_shdrp[count]->sh_size))
  2536.         return false;
  2537.     }
  2538.     }
  2539.  
  2540.   /* Write out the section header names.  */
  2541.   if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
  2542.       || ! _bfd_stringtab_emit (abfd, elf_shstrtab (abfd)))
  2543.     return false;
  2544.  
  2545.   if (bed->elf_backend_final_write_processing)
  2546.     (*bed->elf_backend_final_write_processing) (abfd,
  2547.                         elf_tdata (abfd)->linker);
  2548.  
  2549.   return bed->s->write_shdrs_and_ehdr (abfd);
  2550. }
  2551.  
  2552. /* given a section, search the header to find them... */
  2553. int
  2554. _bfd_elf_section_from_bfd_section (abfd, asect)
  2555.      bfd *abfd;
  2556.      struct sec *asect;
  2557. {
  2558.   struct elf_backend_data *bed = get_elf_backend_data (abfd);
  2559.   Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
  2560.   int index;
  2561.   Elf_Internal_Shdr *hdr;
  2562.   int maxindex = elf_elfheader (abfd)->e_shnum;
  2563.  
  2564.   for (index = 0; index < maxindex; index++)
  2565.     {
  2566.       hdr = i_shdrp[index];
  2567.       if (hdr->bfd_section == asect)
  2568.     return index;
  2569.     }
  2570.  
  2571.   if (bed->elf_backend_section_from_bfd_section)
  2572.     {
  2573.       for (index = 0; index < maxindex; index++)
  2574.     {
  2575.       int retval;
  2576.  
  2577.       hdr = i_shdrp[index];
  2578.       retval = index;
  2579.       if ((*bed->elf_backend_section_from_bfd_section)
  2580.           (abfd, hdr, asect, &retval))
  2581.         return retval;
  2582.     }
  2583.     }
  2584.  
  2585.   if (bfd_is_abs_section (asect))
  2586.     return SHN_ABS;
  2587.   if (bfd_is_com_section (asect))
  2588.     return SHN_COMMON;
  2589.   if (bfd_is_und_section (asect))
  2590.     return SHN_UNDEF;
  2591.  
  2592.   return -1;
  2593. }
  2594.  
  2595. /* Given a BFD symbol, return the index in the ELF symbol table, or -1
  2596.    on error.  */
  2597.  
  2598. int
  2599. _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
  2600.      bfd *abfd;
  2601.      asymbol **asym_ptr_ptr;
  2602. {
  2603.   asymbol *asym_ptr = *asym_ptr_ptr;
  2604.   int idx;
  2605.   flagword flags = asym_ptr->flags;
  2606.  
  2607.   /* When gas creates relocations against local labels, it creates its
  2608.      own symbol for the section, but does put the symbol into the
  2609.      symbol chain, so udata is 0.  When the linker is generating
  2610.      relocatable output, this section symbol may be for one of the
  2611.      input sections rather than the output section.  */
  2612.   if (asym_ptr->udata.i == 0
  2613.       && (flags & BSF_SECTION_SYM)
  2614.       && asym_ptr->section)
  2615.     {
  2616.       int indx;
  2617.  
  2618.       if (asym_ptr->section->output_section != NULL)
  2619.     indx = asym_ptr->section->output_section->index;
  2620.       else
  2621.     indx = asym_ptr->section->index;
  2622.       if (elf_section_syms (abfd)[indx])
  2623.     asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
  2624.     }
  2625.  
  2626.   idx = asym_ptr->udata.i;
  2627.  
  2628.   if (idx == 0)
  2629.     {
  2630.       /* This case can occur when using --strip-symbol on a symbol
  2631.          which is used in a relocation entry.  */
  2632.       (*_bfd_error_handler)
  2633.     ("%s: symbol `%s' required but not present",
  2634.      bfd_get_filename (abfd), bfd_asymbol_name (asym_ptr));
  2635.       bfd_set_error (bfd_error_no_symbols);
  2636.       return -1;
  2637.     }
  2638.  
  2639. #if DEBUG & 4
  2640.   {
  2641.     fprintf (stderr,
  2642.          "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
  2643.          (long) asym_ptr, asym_ptr->name, idx, flags,
  2644.          elf_symbol_flags (flags));
  2645.     fflush (stderr);
  2646.   }
  2647. #endif
  2648.  
  2649.   return idx;
  2650. }
  2651.  
  2652. /* Copy private BFD data.  This copies any program header information.  */
  2653.  
  2654. static boolean
  2655. copy_private_bfd_data (ibfd, obfd)
  2656.      bfd *ibfd;
  2657.      bfd *obfd;
  2658. {
  2659.   Elf_Internal_Ehdr *iehdr;
  2660.   struct elf_segment_map *mfirst;
  2661.   struct elf_segment_map **pm;
  2662.   Elf_Internal_Phdr *p;
  2663.   unsigned int i, c;
  2664.  
  2665.   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
  2666.       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
  2667.     return true;
  2668.  
  2669.   if (elf_tdata (ibfd)->phdr == NULL)
  2670.     return true;
  2671.  
  2672.   iehdr = elf_elfheader (ibfd);
  2673.  
  2674.   mfirst = NULL;
  2675.   pm = &mfirst;
  2676.  
  2677.   c = elf_elfheader (ibfd)->e_phnum;
  2678.   for (i = 0, p = elf_tdata (ibfd)->phdr; i < c; i++, p++)
  2679.     {
  2680.       unsigned int csecs;
  2681.       asection *s;
  2682.       struct elf_segment_map *m;
  2683.       unsigned int isec;
  2684.  
  2685.       csecs = 0;
  2686.  
  2687.       /* The complicated case when p_vaddr is 0 is to handle the
  2688.      Solaris linker, which generates a PT_INTERP section with
  2689.      p_vaddr and p_memsz set to 0.  */
  2690.       for (s = ibfd->sections; s != NULL; s = s->next)
  2691.     if (((s->vma >= p->p_vaddr
  2692.           && (s->vma + s->_raw_size <= p->p_vaddr + p->p_memsz
  2693.           || s->vma + s->_raw_size <= p->p_vaddr + p->p_filesz))
  2694.          || (p->p_vaddr == 0
  2695.          && p->p_filesz > 0
  2696.          && (s->flags & SEC_HAS_CONTENTS) != 0
  2697.          && (bfd_vma) s->filepos >= p->p_offset
  2698.          && ((bfd_vma) s->filepos + s->_raw_size
  2699.              <= p->p_offset + p->p_filesz)))
  2700.         && (s->flags & SEC_ALLOC) != 0
  2701.         && s->output_section != NULL)
  2702.       ++csecs;
  2703.  
  2704.       m = ((struct elf_segment_map *)
  2705.        bfd_alloc (obfd,
  2706.               (sizeof (struct elf_segment_map)
  2707.                + (csecs - 1) * sizeof (asection *))));
  2708.       if (m == NULL)
  2709.     return false;
  2710.  
  2711.       m->next = NULL;
  2712.       m->p_type = p->p_type;
  2713.       m->p_flags = p->p_flags;
  2714.       m->p_flags_valid = 1;
  2715.       m->p_paddr = p->p_paddr;
  2716.       m->p_paddr_valid = 1;
  2717.  
  2718.       m->includes_filehdr = (p->p_offset == 0
  2719.                  && p->p_filesz >= iehdr->e_ehsize);
  2720.  
  2721.       m->includes_phdrs = (p->p_offset <= (bfd_vma) iehdr->e_phoff
  2722.                && (p->p_offset + p->p_filesz
  2723.                    >= ((bfd_vma) iehdr->e_phoff
  2724.                    + iehdr->e_phnum * iehdr->e_phentsize)));
  2725.  
  2726.       isec = 0;
  2727.       for (s = ibfd->sections; s != NULL; s = s->next)
  2728.     {
  2729.       if (((s->vma >= p->p_vaddr
  2730.         && (s->vma + s->_raw_size <= p->p_vaddr + p->p_memsz
  2731.             || s->vma + s->_raw_size <= p->p_vaddr + p->p_filesz))
  2732.            || (p->p_vaddr == 0
  2733.            && p->p_filesz > 0
  2734.            && (s->flags & SEC_HAS_CONTENTS) != 0
  2735.            && (bfd_vma) s->filepos >= p->p_offset
  2736.            && ((bfd_vma) s->filepos + s->_raw_size
  2737.                <= p->p_offset + p->p_filesz)))
  2738.           && (s->flags & SEC_ALLOC) != 0
  2739.           && s->output_section != NULL)
  2740.         {
  2741.           m->sections[isec] = s->output_section;
  2742.           ++isec;
  2743.         }
  2744.     }
  2745.       BFD_ASSERT (isec == csecs);
  2746.       m->count = csecs;
  2747.  
  2748.       *pm = m;
  2749.       pm = &m->next;
  2750.     }
  2751.  
  2752.   elf_tdata (obfd)->segment_map = mfirst;
  2753.  
  2754.   return true;
  2755. }
  2756.  
  2757. /* Copy private section information.  This copies over the entsize
  2758.    field, and sometimes the info field.  */
  2759.  
  2760. boolean
  2761. _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
  2762.      bfd *ibfd;
  2763.      asection *isec;
  2764.      bfd *obfd;
  2765.      asection *osec;
  2766. {
  2767.   Elf_Internal_Shdr *ihdr, *ohdr;
  2768.  
  2769.   if (ibfd->xvec->flavour != bfd_target_elf_flavour
  2770.       || obfd->xvec->flavour != bfd_target_elf_flavour)
  2771.     return true;
  2772.  
  2773.   /* Copy over private BFD data if it has not already been copied.
  2774.      This must be done here, rather than in the copy_private_bfd_data
  2775.      entry point, because the latter is called after the section
  2776.      contents have been set, which means that the program headers have
  2777.      already been worked out.  */
  2778.   if (elf_tdata (obfd)->segment_map == NULL
  2779.       && elf_tdata (ibfd)->phdr != NULL)
  2780.     {
  2781.       asection *s;
  2782.  
  2783.       /* Only set up the segments when all the sections have been set
  2784.          up.  */
  2785.       for (s = ibfd->sections; s != NULL; s = s->next)
  2786.     if (s->output_section == NULL)
  2787.       break;
  2788.       if (s == NULL)
  2789.     {
  2790.       if (! copy_private_bfd_data (ibfd, obfd))
  2791.         return false;
  2792.     }
  2793.     }
  2794.  
  2795.   ihdr = &elf_section_data (isec)->this_hdr;
  2796.   ohdr = &elf_section_data (osec)->this_hdr;
  2797.  
  2798.   ohdr->sh_entsize = ihdr->sh_entsize;
  2799.  
  2800.   if (ihdr->sh_type == SHT_SYMTAB
  2801.       || ihdr->sh_type == SHT_DYNSYM)
  2802.     ohdr->sh_info = ihdr->sh_info;
  2803.  
  2804.   return true;
  2805. }
  2806.  
  2807. /* Copy private symbol information.  If this symbol is in a section
  2808.    which we did not map into a BFD section, try to map the section
  2809.    index correctly.  We use special macro definitions for the mapped
  2810.    section indices; these definitions are interpreted by the
  2811.    swap_out_syms function.  */
  2812.  
  2813. #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
  2814. #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
  2815. #define MAP_STRTAB (SHN_LORESERVE - 3)
  2816. #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
  2817.  
  2818. boolean
  2819. _bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
  2820.      bfd *ibfd;
  2821.      asymbol *isymarg;
  2822.      bfd *obfd;
  2823.      asymbol *osymarg;
  2824. {
  2825.   elf_symbol_type *isym, *osym;
  2826.  
  2827.   isym = elf_symbol_from (ibfd, isymarg);
  2828.   osym = elf_symbol_from (obfd, osymarg);
  2829.  
  2830.   if (isym != NULL
  2831.       && osym != NULL
  2832.       && bfd_is_abs_section (isym->symbol.section))
  2833.     {
  2834.       unsigned int shndx;
  2835.  
  2836.       shndx = isym->internal_elf_sym.st_shndx;
  2837.       if (shndx == elf_onesymtab (ibfd))
  2838.     shndx = MAP_ONESYMTAB;
  2839.       else if (shndx == elf_dynsymtab (ibfd))
  2840.     shndx = MAP_DYNSYMTAB;
  2841.       else if (shndx == elf_tdata (ibfd)->strtab_section)
  2842.     shndx = MAP_STRTAB;
  2843.       else if (shndx == elf_tdata (ibfd)->shstrtab_section)
  2844.     shndx = MAP_SHSTRTAB;
  2845.       osym->internal_elf_sym.st_shndx = shndx;
  2846.     }
  2847.  
  2848.   return true;
  2849. }
  2850.  
  2851. /* Swap out the symbols.  */
  2852.  
  2853. static boolean
  2854. swap_out_syms (abfd, sttp)
  2855.      bfd *abfd;
  2856.      struct bfd_strtab_hash **sttp;
  2857. {
  2858.   struct elf_backend_data *bed = get_elf_backend_data (abfd);
  2859.  
  2860.   if (!elf_map_symbols (abfd))
  2861.     return false;
  2862.  
  2863.   /* Dump out the symtabs. */
  2864.   {
  2865.     int symcount = bfd_get_symcount (abfd);
  2866.     asymbol **syms = bfd_get_outsymbols (abfd);
  2867.     struct bfd_strtab_hash *stt;
  2868.     Elf_Internal_Shdr *symtab_hdr;
  2869.     Elf_Internal_Shdr *symstrtab_hdr;
  2870.     char *outbound_syms;
  2871.     int idx;
  2872.  
  2873.     stt = _bfd_elf_stringtab_init ();
  2874.     if (stt == NULL)
  2875.       return false;
  2876.  
  2877.     symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
  2878.     symtab_hdr->sh_type = SHT_SYMTAB;
  2879.     symtab_hdr->sh_entsize = bed->s->sizeof_sym;
  2880.     symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
  2881.     symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
  2882.     symtab_hdr->sh_addralign = bed->s->file_align;
  2883.  
  2884.     symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
  2885.     symstrtab_hdr->sh_type = SHT_STRTAB;
  2886.  
  2887.     outbound_syms = bfd_alloc (abfd,
  2888.                    (1 + symcount) * bed->s->sizeof_sym);
  2889.     if (outbound_syms == NULL)
  2890.       return false;
  2891.     symtab_hdr->contents = (PTR) outbound_syms;
  2892.  
  2893.     /* now generate the data (for "contents") */
  2894.     {
  2895.       /* Fill in zeroth symbol and swap it out.  */
  2896.       Elf_Internal_Sym sym;
  2897.       sym.st_name = 0;
  2898.       sym.st_value = 0;
  2899.       sym.st_size = 0;
  2900.       sym.st_info = 0;
  2901.       sym.st_other = 0;
  2902.       sym.st_shndx = SHN_UNDEF;
  2903.       bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
  2904.       outbound_syms += bed->s->sizeof_sym;
  2905.     }
  2906.     for (idx = 0; idx < symcount; idx++)
  2907.       {
  2908.     Elf_Internal_Sym sym;
  2909.     bfd_vma value = syms[idx]->value;
  2910.     elf_symbol_type *type_ptr;
  2911.     flagword flags = syms[idx]->flags;
  2912.     int type;
  2913.  
  2914.     if (flags & BSF_SECTION_SYM)
  2915.       /* Section symbols have no names.  */
  2916.       sym.st_name = 0;
  2917.     else
  2918.       {
  2919.         sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
  2920.                                   syms[idx]->name,
  2921.                                   true, false);
  2922.         if (sym.st_name == (unsigned long) -1)
  2923.           return false;
  2924.       }
  2925.  
  2926.     type_ptr = elf_symbol_from (abfd, syms[idx]);
  2927.  
  2928.     if (bfd_is_com_section (syms[idx]->section))
  2929.       {
  2930.         /* ELF common symbols put the alignment into the `value' field,
  2931.            and the size into the `size' field.  This is backwards from
  2932.            how BFD handles it, so reverse it here.  */
  2933.         sym.st_size = value;
  2934.         if (type_ptr == NULL
  2935.         || type_ptr->internal_elf_sym.st_value == 0)
  2936.           sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
  2937.         else
  2938.           sym.st_value = type_ptr->internal_elf_sym.st_value;
  2939.         sym.st_shndx = _bfd_elf_section_from_bfd_section (abfd,
  2940.                                   syms[idx]->section);
  2941.       }
  2942.     else
  2943.       {
  2944.         asection *sec = syms[idx]->section;
  2945.         int shndx;
  2946.  
  2947.         if (sec->output_section)
  2948.           {
  2949.         value += sec->output_offset;
  2950.         sec = sec->output_section;
  2951.           }
  2952.         value += sec->vma;
  2953.         sym.st_value = value;
  2954.         sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
  2955.  
  2956.         if (bfd_is_abs_section (sec)
  2957.         && type_ptr != NULL
  2958.         && type_ptr->internal_elf_sym.st_shndx != 0)
  2959.           {
  2960.         /* This symbol is in a real ELF section which we did
  2961.                    not create as a BFD section.  Undo the mapping done
  2962.                    by copy_private_symbol_data.  */
  2963.         shndx = type_ptr->internal_elf_sym.st_shndx;
  2964.         switch (shndx)
  2965.           {
  2966.           case MAP_ONESYMTAB:
  2967.             shndx = elf_onesymtab (abfd);
  2968.             break;
  2969.           case MAP_DYNSYMTAB:
  2970.             shndx = elf_dynsymtab (abfd);
  2971.             break;
  2972.           case MAP_STRTAB:
  2973.             shndx = elf_tdata (abfd)->strtab_section;
  2974.             break;
  2975.           case MAP_SHSTRTAB:
  2976.             shndx = elf_tdata (abfd)->shstrtab_section;
  2977.             break;
  2978.           default:
  2979.             break;
  2980.           }
  2981.           }
  2982.         else
  2983.           {
  2984.         shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
  2985.  
  2986.         if (shndx == -1)
  2987.           {
  2988.             asection *sec2;
  2989.  
  2990.             /* Writing this would be a hell of a lot easier if
  2991.                we had some decent documentation on bfd, and
  2992.                knew what to expect of the library, and what to
  2993.                demand of applications.  For example, it
  2994.                appears that `objcopy' might not set the
  2995.                section of a symbol to be a section that is
  2996.                actually in the output file.  */
  2997.             sec2 = bfd_get_section_by_name (abfd, sec->name);
  2998.             BFD_ASSERT (sec2 != 0);
  2999.             shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
  3000.             BFD_ASSERT (shndx != -1);
  3001.           }
  3002.           }
  3003.  
  3004.         sym.st_shndx = shndx;
  3005.       }
  3006.  
  3007.     if ((flags & BSF_FUNCTION) != 0)
  3008.       type = STT_FUNC;
  3009.     else if ((flags & BSF_OBJECT) != 0)
  3010.       type = STT_OBJECT;
  3011.     else
  3012.       type = STT_NOTYPE;
  3013.  
  3014.     if (bfd_is_com_section (syms[idx]->section))
  3015.       sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
  3016.     else if (bfd_is_und_section (syms[idx]->section))
  3017.       sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
  3018.                       ? STB_WEAK
  3019.                       : STB_GLOBAL),
  3020.                      type);
  3021.     else if (flags & BSF_SECTION_SYM)
  3022.       sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
  3023.     else if (flags & BSF_FILE)
  3024.       sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
  3025.     else
  3026.       {
  3027.         int bind = STB_LOCAL;
  3028.  
  3029.         if (flags & BSF_LOCAL)
  3030.           bind = STB_LOCAL;
  3031.         else if (flags & BSF_WEAK)
  3032.           bind = STB_WEAK;
  3033.         else if (flags & BSF_GLOBAL)
  3034.           bind = STB_GLOBAL;
  3035.  
  3036.         sym.st_info = ELF_ST_INFO (bind, type);
  3037.       }
  3038.  
  3039.     sym.st_other = 0;
  3040.     bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
  3041.     outbound_syms += bed->s->sizeof_sym;
  3042.       }
  3043.  
  3044.     *sttp = stt;
  3045.     symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
  3046.     symstrtab_hdr->sh_type = SHT_STRTAB;
  3047.  
  3048.     symstrtab_hdr->sh_flags = 0;
  3049.     symstrtab_hdr->sh_addr = 0;
  3050.     symstrtab_hdr->sh_entsize = 0;
  3051.     symstrtab_hdr->sh_link = 0;
  3052.     symstrtab_hdr->sh_info = 0;
  3053.     symstrtab_hdr->sh_addralign = 1;
  3054.   }
  3055.  
  3056.   return true;
  3057. }
  3058.  
  3059. /* Return the number of bytes required to hold the symtab vector.
  3060.  
  3061.    Note that we base it on the count plus 1, since we will null terminate
  3062.    the vector allocated based on this size.  However, the ELF symbol table
  3063.    always has a dummy entry as symbol #0, so it ends up even.  */
  3064.  
  3065. long
  3066. _bfd_elf_get_symtab_upper_bound (abfd)
  3067.      bfd *abfd;
  3068. {
  3069.   long symcount;
  3070.   long symtab_size;
  3071.   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
  3072.  
  3073.   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
  3074.   symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
  3075.  
  3076.   return symtab_size;
  3077. }
  3078.  
  3079. long
  3080. _bfd_elf_get_dynamic_symtab_upper_bound (abfd)
  3081.      bfd *abfd;
  3082. {
  3083.   long symcount;
  3084.   long symtab_size;
  3085.   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
  3086.  
  3087.   if (elf_dynsymtab (abfd) == 0)
  3088.     {
  3089.       bfd_set_error (bfd_error_invalid_operation);
  3090.       return -1;
  3091.     }
  3092.  
  3093.   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
  3094.   symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
  3095.  
  3096.   return symtab_size;
  3097. }
  3098.  
  3099. long
  3100. _bfd_elf_get_reloc_upper_bound (abfd, asect)
  3101.      bfd *abfd;
  3102.      sec_ptr asect;
  3103. {
  3104.   return (asect->reloc_count + 1) * sizeof (arelent *);
  3105. }
  3106.  
  3107. /* Canonicalize the relocs.  */
  3108.  
  3109. long
  3110. _bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
  3111.      bfd *abfd;
  3112.      sec_ptr section;
  3113.      arelent **relptr;
  3114.      asymbol **symbols;
  3115. {
  3116.   arelent *tblptr;
  3117.   unsigned int i;
  3118.  
  3119.   if (! get_elf_backend_data (abfd)->s->slurp_reloc_table (abfd, section, symbols))
  3120.     return -1;
  3121.  
  3122.   tblptr = section->relocation;
  3123.   for (i = 0; i < section->reloc_count; i++)
  3124.     *relptr++ = tblptr++;
  3125.  
  3126.   *relptr = NULL;
  3127.  
  3128.   return section->reloc_count;
  3129. }
  3130.  
  3131. long
  3132. _bfd_elf_get_symtab (abfd, alocation)
  3133.      bfd *abfd;
  3134.      asymbol **alocation;
  3135. {
  3136.   long symcount = get_elf_backend_data (abfd)->s->slurp_symbol_table (abfd, alocation, false);
  3137.  
  3138.   if (symcount >= 0)
  3139.     bfd_get_symcount (abfd) = symcount;
  3140.   return symcount;
  3141. }
  3142.  
  3143. long
  3144. _bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
  3145.      bfd *abfd;
  3146.      asymbol **alocation;
  3147. {
  3148.   return get_elf_backend_data (abfd)->s->slurp_symbol_table (abfd, alocation, true);
  3149. }
  3150.  
  3151. asymbol *
  3152. _bfd_elf_make_empty_symbol (abfd)
  3153.      bfd *abfd;
  3154. {
  3155.   elf_symbol_type *newsym;
  3156.  
  3157.   newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
  3158.   if (!newsym)
  3159.     return NULL;
  3160.   else
  3161.     {
  3162.       newsym->symbol.the_bfd = abfd;
  3163.       return &newsym->symbol;
  3164.     }
  3165. }
  3166.  
  3167. void
  3168. _bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
  3169.      bfd *ignore_abfd;
  3170.      asymbol *symbol;
  3171.      symbol_info *ret;
  3172. {
  3173.   bfd_symbol_info (symbol, ret);
  3174. }
  3175.  
  3176. alent *
  3177. _bfd_elf_get_lineno (ignore_abfd, symbol)
  3178.      bfd *ignore_abfd;
  3179.      asymbol *symbol;
  3180. {
  3181.   abort ();
  3182.   return NULL;
  3183. }
  3184.  
  3185. boolean
  3186. _bfd_elf_set_arch_mach (abfd, arch, machine)
  3187.      bfd *abfd;
  3188.      enum bfd_architecture arch;
  3189.      unsigned long machine;
  3190. {
  3191.   /* If this isn't the right architecture for this backend, and this
  3192.      isn't the generic backend, fail.  */
  3193.   if (arch != get_elf_backend_data (abfd)->arch
  3194.       && arch != bfd_arch_unknown
  3195.       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
  3196.     return false;
  3197.  
  3198.   return bfd_default_set_arch_mach (abfd, arch, machine);
  3199. }
  3200.  
  3201. /* Find the nearest line to a particular section and offset, for error
  3202.    reporting.  */
  3203.  
  3204. boolean
  3205. _bfd_elf_find_nearest_line (abfd,
  3206.                 section,
  3207.                 symbols,
  3208.                 offset,
  3209.                 filename_ptr,
  3210.                 functionname_ptr,
  3211.                 line_ptr)
  3212.      bfd *abfd;
  3213.      asection *section;
  3214.      asymbol **symbols;
  3215.      bfd_vma offset;
  3216.      CONST char **filename_ptr;
  3217.      CONST char **functionname_ptr;
  3218.      unsigned int *line_ptr;
  3219. {
  3220.   boolean found;
  3221.   const char *filename;
  3222.   asymbol *func;
  3223.   bfd_vma low_func;
  3224.   asymbol **p;
  3225.  
  3226.   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
  3227.                          &found, filename_ptr,
  3228.                          functionname_ptr, line_ptr,
  3229.                          &elf_tdata (abfd)->line_info))
  3230.     return false;
  3231.   if (found)
  3232.     return true;
  3233.  
  3234.   if (symbols == NULL)
  3235.     return false;
  3236.  
  3237.   filename = NULL;
  3238.   func = NULL;
  3239.   low_func = 0;
  3240.  
  3241.   for (p = symbols; *p != NULL; p++)
  3242.     {
  3243.       elf_symbol_type *q;
  3244.  
  3245.       q = (elf_symbol_type *) *p;
  3246.  
  3247.       if (bfd_get_section (&q->symbol) != section)
  3248.     continue;
  3249.  
  3250.       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
  3251.     {
  3252.     default:
  3253.       break;
  3254.     case STT_FILE:
  3255.       filename = bfd_asymbol_name (&q->symbol);
  3256.       break;
  3257.     case STT_FUNC:
  3258.       if (q->symbol.section == section
  3259.           && q->symbol.value >= low_func
  3260.           && q->symbol.value <= offset)
  3261.         {
  3262.           func = (asymbol *) q;
  3263.           low_func = q->symbol.value;
  3264.         }
  3265.       break;
  3266.     }
  3267.     }
  3268.  
  3269.   if (func == NULL)
  3270.     return false;
  3271.  
  3272.   *filename_ptr = filename;
  3273.   *functionname_ptr = bfd_asymbol_name (func);
  3274.   *line_ptr = 0;
  3275.   return true;
  3276. }
  3277.  
  3278. int
  3279. _bfd_elf_sizeof_headers (abfd, reloc)
  3280.      bfd *abfd;
  3281.      boolean reloc;
  3282. {
  3283.   int ret;
  3284.  
  3285.   ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
  3286.   if (! reloc)
  3287.     ret += get_program_header_size (abfd);
  3288.   return ret;
  3289. }
  3290.  
  3291. boolean
  3292. _bfd_elf_set_section_contents (abfd, section, location, offset, count)
  3293.      bfd *abfd;
  3294.      sec_ptr section;
  3295.      PTR location;
  3296.      file_ptr offset;
  3297.      bfd_size_type count;
  3298. {
  3299.   Elf_Internal_Shdr *hdr;
  3300.  
  3301.   if (! abfd->output_has_begun
  3302.       && ! _bfd_elf_compute_section_file_positions (abfd,
  3303.                             (struct bfd_link_info *) NULL))
  3304.     return false;
  3305.  
  3306.   hdr = &elf_section_data (section)->this_hdr;
  3307.  
  3308.   if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1)
  3309.     return false;
  3310.   if (bfd_write (location, 1, count, abfd) != count)
  3311.     return false;
  3312.  
  3313.   return true;
  3314. }
  3315.  
  3316. void
  3317. _bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
  3318.      bfd *abfd;
  3319.      arelent *cache_ptr;
  3320.      Elf_Internal_Rela *dst;
  3321. {
  3322.   abort ();
  3323. }
  3324.  
  3325. #if 0
  3326. void
  3327. _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
  3328.      bfd *abfd;
  3329.      arelent *cache_ptr;
  3330.      Elf_Internal_Rel *dst;
  3331. {
  3332.   abort ();
  3333. }
  3334. #endif
  3335.  
  3336. /* Try to convert a non-ELF reloc into an ELF one.  */
  3337.  
  3338. boolean
  3339. _bfd_elf_validate_reloc (abfd, areloc)
  3340.      bfd *abfd;
  3341.      arelent *areloc;
  3342. {
  3343.   /* Check whether we really have an ELF howto. */
  3344.  
  3345.   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec) 
  3346.     {
  3347.       bfd_reloc_code_real_type code;
  3348.       reloc_howto_type *howto;
  3349.       
  3350.       /* Alien reloc: Try to determine its type to replace it with an
  3351.      equivalent ELF reloc. */
  3352.  
  3353.       if (areloc->howto->pc_relative)
  3354.     {
  3355.       switch (areloc->howto->bitsize)
  3356.         {
  3357.         case 8:
  3358.           code = BFD_RELOC_8_PCREL; 
  3359.           break;
  3360.         case 12:
  3361.           code = BFD_RELOC_12_PCREL; 
  3362.           break;
  3363.         case 16:
  3364.           code = BFD_RELOC_16_PCREL; 
  3365.           break;
  3366.         case 24:
  3367.           code = BFD_RELOC_24_PCREL; 
  3368.           break;
  3369.         case 32:
  3370.           code = BFD_RELOC_32_PCREL; 
  3371.           break;
  3372.         case 64:
  3373.           code = BFD_RELOC_64_PCREL; 
  3374.           break;
  3375.         default:
  3376.           goto fail;
  3377.         }
  3378.  
  3379.       howto = bfd_reloc_type_lookup (abfd, code);
  3380.  
  3381.       if (areloc->howto->pcrel_offset != howto->pcrel_offset)
  3382.         {
  3383.           if (howto->pcrel_offset)
  3384.         areloc->addend += areloc->address;
  3385.           else
  3386.         areloc->addend -= areloc->address; /* addend is unsigned!! */
  3387.         }
  3388.     }
  3389.       else
  3390.     {
  3391.       switch (areloc->howto->bitsize)
  3392.         {
  3393.         case 8:
  3394.           code = BFD_RELOC_8; 
  3395.           break;
  3396.         case 14:
  3397.           code = BFD_RELOC_14; 
  3398.           break;
  3399.         case 16:
  3400.           code = BFD_RELOC_16; 
  3401.           break;
  3402.         case 26:
  3403.           code = BFD_RELOC_26; 
  3404.           break;
  3405.         case 32:
  3406.           code = BFD_RELOC_32; 
  3407.           break;
  3408.         case 64:
  3409.           code = BFD_RELOC_64; 
  3410.           break;
  3411.         default:
  3412.           goto fail;
  3413.         }
  3414.  
  3415.       howto = bfd_reloc_type_lookup (abfd, code);
  3416.     }
  3417.  
  3418.       if (howto)
  3419.     areloc->howto = howto;
  3420.       else
  3421.     goto fail;
  3422.     }
  3423.  
  3424.   return true;
  3425.  
  3426.  fail:
  3427.   (*_bfd_error_handler)
  3428.     ("%s: unsupported relocation type %s",
  3429.      bfd_get_filename (abfd), areloc->howto->name);
  3430.   bfd_set_error (bfd_error_bad_value);
  3431.   return false;
  3432. }
  3433.